Example 11 with Pair
use of org.eclipse.xtext.xbase.lib.Pair in project erlide_eclipse by erlang.
the class ErlideSelection method getLineAndCol.
/**
* @param offset
* the offset we want info on
* @return a tuple with the line, col of the passed offset in the document
*/
public Pair<Integer, Integer> getLineAndCol(final int offset) {
try {
final IRegion region = doc.getLineInformationOfOffset(offset);
final int line = doc.getLineOfOffset(offset);
final int col = offset - region.getOffset();
return new Pair<>(line, col);
} catch (final BadLocationException e) {
throw new RuntimeException(e);
}
}
Also used :
IRegion(org.eclipse.jface.text.IRegion)
BadLocationException(org.eclipse.jface.text.BadLocationException)
Pair(org.eclipse.xtext.xbase.lib.Pair)
Example 12 with Pair
use of org.eclipse.xtext.xbase.lib.Pair in project n4js by eclipse.
the class Reducer method isSubtypeOf.
/**
* Convenience method to perform subtype checks. Depending on the given variance, this will check
* <code>left <: right</code> OR <code>left >: right</code> OR both.
*/
private boolean isSubtypeOf(TypeRef left, TypeRef right, Variance variance) {
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// recursion guard
final Pair<String, Pair<TypeRef, TypeRef>> key = Pair.of(RuleEnvironmentExtensions.GUARD_REDUCER_IS_SUBTYPE_OF, Pair.of(left, right));
if (G.get(key) != null) {
return true;
}
final RuleEnvironment G2 = RuleEnvironmentExtensions.wrap(G);
G2.add(key, Boolean.TRUE);
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
switch(variance) {
case CO:
return ts.subtypeSucceeded(G2, left, right);
case CONTRA:
return ts.subtypeSucceeded(G2, right, left);
case INV:
return ts.equaltypeSucceeded(G2, left, right);
}
// actually unreachable, each case above returns
throw new IllegalStateException("unreachable");
}
Also used :
RuleEnvironment(org.eclipse.xsemantics.runtime.RuleEnvironment)
Pair(org.eclipse.xtext.xbase.lib.Pair)
Example 13 with Pair
use of org.eclipse.xtext.xbase.lib.Pair in project n4js by eclipse.
the class InternalTypeSystem method applyRuleSubtypeParameterizedTypeRef.
protected Result<Boolean> applyRuleSubtypeParameterizedTypeRef(final RuleEnvironment G, final RuleApplicationTrace _trace_, final ParameterizedTypeRef leftOriginal, final ParameterizedTypeRef rightOriginal) throws RuleFailedException {
final TypeRef left = RuleEnvironmentExtensions.getReplacement(G, leftOriginal);
final TypeRef right = RuleEnvironmentExtensions.getReplacement(G, rightOriginal);
final Type leftDeclType = left.getDeclaredType();
final Type rightDeclType = right.getDeclaredType();
if (((leftDeclType == null) || (rightDeclType == null))) {
/* true */
if (!true) {
sneakyThrowRuleFailedException("true");
}
} else {
if ((leftDeclType.eIsProxy() || rightDeclType.eIsProxy())) {
/* true */
if (!true) {
sneakyThrowRuleFailedException("true");
}
} else {
if (((leftDeclType instanceof VoidType) || (rightDeclType instanceof VoidType))) {
/* leftDeclType instanceof VoidType && rightDeclType instanceof VoidType */
if (!((leftDeclType instanceof VoidType) && (rightDeclType instanceof VoidType))) {
sneakyThrowRuleFailedException("leftDeclType instanceof VoidType && rightDeclType instanceof VoidType");
}
} else {
if ((((leftDeclType instanceof UndefinedType) || ((leftDeclType instanceof NullType) && (!(rightDeclType instanceof UndefinedType)))) || (rightDeclType instanceof AnyType))) {
/* true */
if (!true) {
sneakyThrowRuleFailedException("true");
}
} else {
if ((((leftDeclType == RuleEnvironmentExtensions.intType(G)) && (rightDeclType == RuleEnvironmentExtensions.numberType(G))) || ((leftDeclType == RuleEnvironmentExtensions.numberType(G)) && (rightDeclType == RuleEnvironmentExtensions.intType(G))))) {
/* true */
if (!true) {
sneakyThrowRuleFailedException("true");
}
} else {
if (((leftDeclType instanceof TEnum) && ((rightDeclType == RuleEnvironmentExtensions.n4EnumType(G)) || (rightDeclType == RuleEnvironmentExtensions.objectType(G))))) {
boolean _hasAnnotation = AnnotationDefinition.STRING_BASED.hasAnnotation(leftDeclType);
/* !AnnotationDefinition.STRING_BASED.hasAnnotation( leftDeclType ) */
if (!(!_hasAnnotation)) {
sneakyThrowRuleFailedException("!AnnotationDefinition.STRING_BASED.hasAnnotation( leftDeclType )");
}
} else {
if (((leftDeclType instanceof TEnum) && (((rightDeclType == RuleEnvironmentExtensions.n4StringBasedEnumType(G)) || (rightDeclType == RuleEnvironmentExtensions.stringType(G))) || (rightDeclType == RuleEnvironmentExtensions.stringObjectType(G))))) {
/* AnnotationDefinition.STRING_BASED.hasAnnotation( leftDeclType ) */
if (!AnnotationDefinition.STRING_BASED.hasAnnotation(leftDeclType)) {
sneakyThrowRuleFailedException("AnnotationDefinition.STRING_BASED.hasAnnotation( leftDeclType )");
}
} else {
if (((leftDeclType == RuleEnvironmentExtensions.n4StringBasedEnumType(G)) && ((rightDeclType == RuleEnvironmentExtensions.stringType(G)) || (rightDeclType == RuleEnvironmentExtensions.stringObjectType(G))))) {
/* true */
if (!true) {
sneakyThrowRuleFailedException("true");
}
} else {
if (((leftDeclType instanceof PrimitiveType) && (((PrimitiveType) leftDeclType).getAssignmentCompatible() == rightDeclType))) {
/* true */
if (!true) {
sneakyThrowRuleFailedException("true");
}
} else {
if (((rightDeclType instanceof PrimitiveType) && (leftDeclType == ((PrimitiveType) rightDeclType).getAssignmentCompatible()))) {
/* true */
if (!true) {
sneakyThrowRuleFailedException("true");
}
} else {
if (((((leftDeclType instanceof TInterface) && (!(rightDeclType instanceof TInterface))) && Objects.equal(right.getTypingStrategy(), TypingStrategy.NOMINAL)) && (!(((rightDeclType == RuleEnvironmentExtensions.n4ObjectType(G)) || (rightDeclType == RuleEnvironmentExtensions.objectType(G))) || (rightDeclType == RuleEnvironmentExtensions.anyType(G)))))) {
/* false */
if (!false) {
sneakyThrowRuleFailedException("false");
}
} else {
boolean structuralTyping = false;
boolean _isUseSiteStructuralTyping = right.isUseSiteStructuralTyping();
if (_isUseSiteStructuralTyping) {
final StructuralTypingResult result = this.typeSystemHelper.isStructuralSubtype(G, left, right);
boolean _isValue = result.isValue();
boolean _not = (!_isValue);
if (_not) {
/* fail error result.message data PRIORITY_ERROR */
String _message = result.getMessage();
String error = _message;
Object data = TypeSystemErrorExtensions.PRIORITY_ERROR;
throwForExplicitFail(error, new ErrorInformation(null, null, data));
}
structuralTyping = true;
} else {
boolean _isDefSiteStructuralTyping = right.isDefSiteStructuralTyping();
if (_isDefSiteStructuralTyping) {
Pair<TypeRef, TypeRef> _mappedTo = Pair.<TypeRef, TypeRef>of(left, right);
Pair<String, Pair<TypeRef, TypeRef>> _mappedTo_1 = Pair.<String, Pair<TypeRef, TypeRef>>of(RuleEnvironmentExtensions.GUARD_SUBTYPE_PARAMETERIZED_TYPE_REF__STRUCT, _mappedTo);
Object _get = G.get(_mappedTo_1);
final Boolean guard = ((Boolean) _get);
if (((guard == null) || (!(guard).booleanValue()))) {
final StructuralTypingResult result_1 = this.typeSystemHelper.isStructuralSubtype(G, left, right);
boolean _isValue_1 = result_1.isValue();
boolean _not_1 = (!_isValue_1);
if (_not_1) {
boolean _and = false;
boolean _isN4ObjectOnLeftWithDefSite = result_1.isN4ObjectOnLeftWithDefSite();
if (!_isN4ObjectOnLeftWithDefSite) {
_and = false;
} else {
/* G.wrap, (GUARD_SUBTYPE_PARAMETERIZED_TYPE_REF__STRUCT->(left->right))<-true |- left <: right */
RuleEnvironment _wrap = RuleEnvironmentExtensions.wrap(G);
Pair<TypeRef, TypeRef> _mappedTo_2 = Pair.<TypeRef, TypeRef>of(left, right);
Pair<String, Pair<TypeRef, TypeRef>> _mappedTo_3 = Pair.<String, Pair<TypeRef, TypeRef>>of(RuleEnvironmentExtensions.GUARD_SUBTYPE_PARAMETERIZED_TYPE_REF__STRUCT, _mappedTo_2);
boolean _ruleinvocation = subtypeSucceeded(environmentComposition(_wrap, environmentEntry(_mappedTo_3, true)), _trace_, left, right);
_and = _ruleinvocation;
}
if (_and) {
structuralTyping = true;
} else {
/* fail error result.message data PRIORITY_ERROR */
String _message_1 = result_1.getMessage();
String error_1 = _message_1;
Object data_1 = TypeSystemErrorExtensions.PRIORITY_ERROR;
throwForExplicitFail(error_1, new ErrorInformation(null, null, data_1));
}
}
structuralTyping = result_1.isValue();
}
}
}
if ((!structuralTyping)) {
if ((((left.isUseSiteStructuralTyping() || left.isDefSiteStructuralTyping()) && (!(Objects.equal(rightDeclType, RuleEnvironmentExtensions.objectType(G)) && (leftDeclType instanceof TClassifier)))) && (!(leftDeclType instanceof PrimitiveType)))) {
/* fail error "Structural type " + left.typeRefAsString + " is not a subtype of non-structural type " + right.typeRefAsString data PRIORITY_ERROR */
String _typeRefAsString = left.getTypeRefAsString();
String _plus = ("Structural type " + _typeRefAsString);
String _plus_1 = (_plus + " is not a subtype of non-structural type ");
String _typeRefAsString_1 = right.getTypeRefAsString();
String _plus_2 = (_plus_1 + _typeRefAsString_1);
String error_2 = _plus_2;
Object data_2 = TypeSystemErrorExtensions.PRIORITY_ERROR;
throwForExplicitFail(error_2, new ErrorInformation(null, null, data_2));
}
if (((leftDeclType instanceof TypeVariable) || (rightDeclType instanceof TypeVariable))) {
boolean _equals = Objects.equal(leftDeclType, rightDeclType);
if (_equals) {
/* true */
if (!true) {
sneakyThrowRuleFailedException("true");
}
} else {
if ((leftDeclType instanceof TypeVariable)) {
TypeRef _elvis = null;
TypeRef _declaredUpperBound = ((TypeVariable) leftDeclType).getDeclaredUpperBound();
if (_declaredUpperBound != null) {
_elvis = _declaredUpperBound;
} else {
TypeRef _typeVariableImplicitUpperBound = N4JSLanguageUtils.getTypeVariableImplicitUpperBound(G);
_elvis = _typeVariableImplicitUpperBound;
}
final TypeRef ub = _elvis;
/* G |- ub <: right */
subtypeInternal(G, _trace_, ub, right);
} else {
/* false */
if (!false) {
sneakyThrowRuleFailedException("false");
}
}
}
} else {
boolean _equals_1 = Objects.equal(leftDeclType, rightDeclType);
if (_equals_1) {
if (((left.getTypeArgs().size() > 0) && (left.getTypeArgs().size() <= right.getTypeArgs().size()))) {
final int len = Math.min(Math.min(left.getTypeArgs().size(), right.getTypeArgs().size()), rightDeclType.getTypeVars().size());
for (int i = 0; (i < len); i++) {
final TypeArgument leftArg = left.getTypeArgs().get(i);
final TypeArgument rightArg = right.getTypeArgs().get(i);
final Variance variance = rightDeclType.getVarianceOfTypeVar(i);
TypeRef leftArgUpper = null;
/* G |~ leftArg /\ leftArgUpper */
Result<TypeRef> result_2 = upperBoundInternal(G, _trace_, leftArg);
checkAssignableTo(result_2.getFirst(), TypeRef.class);
leftArgUpper = (TypeRef) result_2.getFirst();
TypeRef leftArgLower = null;
/* G |~ leftArg \/ leftArgLower */
Result<TypeRef> result_3 = lowerBoundInternal(G, _trace_, leftArg);
checkAssignableTo(result_3.getFirst(), TypeRef.class);
leftArgLower = (TypeRef) result_3.getFirst();
TypeRef rightArgUpper = null;
/* G |~ rightArg /\ rightArgUpper */
Result<TypeRef> result_4 = upperBoundInternal(G, _trace_, rightArg);
checkAssignableTo(result_4.getFirst(), TypeRef.class);
rightArgUpper = (TypeRef) result_4.getFirst();
TypeRef rightArgLower = null;
/* G |~ rightArg \/ rightArgLower */
Result<TypeRef> result_5 = lowerBoundInternal(G, _trace_, rightArg);
checkAssignableTo(result_5.getFirst(), TypeRef.class);
rightArgLower = (TypeRef) result_5.getFirst();
RuleEnvironment G2 = null;
if (((rightArg instanceof Wildcard) && ((Wildcard) rightArg).isImplicitUpperBoundInEffect())) {
Pair<String, TypeArgument> _mappedTo_4 = Pair.<String, TypeArgument>of(RuleEnvironmentExtensions.GUARD_SUBTYPE_PARAMETERIZED_TYPE_REF__ARGS, rightArg);
Object _get_1 = G.get(_mappedTo_4);
final boolean isGuarded = (_get_1 != null);
if ((!isGuarded)) {
G2 = RuleEnvironmentExtensions.wrap(G);
Pair<String, TypeArgument> _mappedTo_5 = Pair.<String, TypeArgument>of(RuleEnvironmentExtensions.GUARD_SUBTYPE_PARAMETERIZED_TYPE_REF__ARGS, rightArg);
/* G2.add(GUARD_SUBTYPE_PARAMETERIZED_TYPE_REF__ARGS->(rightArg), Boolean.TRUE) */
if (!G2.add(_mappedTo_5, Boolean.TRUE)) {
sneakyThrowRuleFailedException("G2.add(GUARD_SUBTYPE_PARAMETERIZED_TYPE_REF__ARGS->(rightArg), Boolean.TRUE)");
}
} else {
rightArgUpper = RuleEnvironmentExtensions.topTypeRef(G);
G2 = G;
}
} else {
G2 = G;
}
/* { if(variance!=Variance.CONTRA) { G2 |- leftArgUpper <: rightArgUpper } if(variance!=Variance.CO) { G2 |- rightArgLower <: leftArgLower } } or { if(previousFailure.isOrCausedByPriorityError) { fail error stringRep(left) + " is not a subtype of " + stringRep(right) + " due to incompatible type arguments: " + previousFailure.compileMessage data PRIORITY_ERROR } else { fail } } */
{
RuleFailedException previousFailure = null;
try {
boolean _notEquals = (!Objects.equal(variance, Variance.CONTRA));
if (_notEquals) {
/* G2 |- leftArgUpper <: rightArgUpper */
subtypeInternal(G2, _trace_, leftArgUpper, rightArgUpper);
}
boolean _notEquals_1 = (!Objects.equal(variance, Variance.CO));
if (_notEquals_1) {
/* G2 |- rightArgLower <: leftArgLower */
subtypeInternal(G2, _trace_, rightArgLower, leftArgLower);
}
} catch (Exception e) {
previousFailure = extractRuleFailedException(e);
boolean _isOrCausedByPriorityError = TypeSystemErrorExtensions.isOrCausedByPriorityError(previousFailure);
if (_isOrCausedByPriorityError) {
/* fail error stringRep(left) + " is not a subtype of " + stringRep(right) + " due to incompatible type arguments: " + previousFailure.compileMessage data PRIORITY_ERROR */
String _stringRep = this.stringRep(left);
String _plus_3 = (_stringRep + " is not a subtype of ");
String _stringRep_1 = this.stringRep(right);
String _plus_4 = (_plus_3 + _stringRep_1);
String _plus_5 = (_plus_4 + " due to incompatible type arguments: ");
String _compileMessage = TypeSystemErrorExtensions.compileMessage(previousFailure);
String _plus_6 = (_plus_5 + _compileMessage);
String error_3 = _plus_6;
Object data_3 = TypeSystemErrorExtensions.PRIORITY_ERROR;
throwForExplicitFail(error_3, new ErrorInformation(null, null, data_3));
} else {
/* fail */
throwForExplicitFail();
}
}
}
}
}
} else {
List<ParameterizedTypeRef> _xifexpression = null;
if ((leftDeclType instanceof ContainerType<?>)) {
_xifexpression = AllSuperTypeRefsCollector.collect(((ContainerType<?>) leftDeclType));
} else {
_xifexpression = CollectionLiterals.<ParameterizedTypeRef>newArrayList();
}
final List<ParameterizedTypeRef> allSuperTypeRefs = _xifexpression;
List<ParameterizedTypeRef> _collectAllImplicitSuperTypes = RuleEnvironmentExtensions.collectAllImplicitSuperTypes(G, left);
final Iterable<ParameterizedTypeRef> superTypeRefs = Iterables.<ParameterizedTypeRef>concat(allSuperTypeRefs, _collectAllImplicitSuperTypes);
final Function1<ParameterizedTypeRef, Boolean> _function = (ParameterizedTypeRef it) -> {
Type _declaredType = it.getDeclaredType();
return Boolean.valueOf((_declaredType == rightDeclType));
};
boolean _exists = IterableExtensions.<ParameterizedTypeRef>exists(superTypeRefs, _function);
if (_exists) {
final RuleEnvironment localG_left = RuleEnvironmentExtensions.wrap(G);
this.typeSystemHelper.addSubstitutions(localG_left, left);
final Function1<TypeVariable, TypeRef> _function_1 = (TypeVariable it) -> {
return TypeExtensions.ref(it);
};
final TypeRef syntheticTypeRef = TypeExtensions.ref(rightDeclType, ((TypeArgument[]) Conversions.unwrapArray(ListExtensions.<TypeVariable, TypeRef>map(rightDeclType.getTypeVars(), _function_1), TypeArgument.class)));
/* localG_left |- syntheticTypeRef ~> var TypeRef effectiveSuperTypeRef */
TypeRef effectiveSuperTypeRef = null;
Result<TypeArgument> result_2 = substTypeVariablesInternal(localG_left, _trace_, syntheticTypeRef);
checkAssignableTo(result_2.getFirst(), TypeRef.class);
effectiveSuperTypeRef = (TypeRef) result_2.getFirst();
/* G |- effectiveSuperTypeRef <: right */
subtypeInternal(G, _trace_, effectiveSuperTypeRef, right);
} else {
/* false */
if (!false) {
sneakyThrowRuleFailedException("false");
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
return new Result<Boolean>(true);
}
Also used :
VoidType(org.eclipse.n4js.ts.types.VoidType)
TClassifier(org.eclipse.n4js.ts.types.TClassifier)
TInterface(org.eclipse.n4js.ts.types.TInterface)
ThisTypeRef(org.eclipse.n4js.ts.typeRefs.ThisTypeRef)
ParameterizedTypeRef(org.eclipse.n4js.ts.typeRefs.ParameterizedTypeRef)
BaseTypeRef(org.eclipse.n4js.ts.typeRefs.BaseTypeRef)
FunctionTypeRef(org.eclipse.n4js.ts.typeRefs.FunctionTypeRef)
ExistentialTypeRef(org.eclipse.n4js.ts.typeRefs.ExistentialTypeRef)
BoundThisTypeRef(org.eclipse.n4js.ts.typeRefs.BoundThisTypeRef)
StructuralTypeRef(org.eclipse.n4js.ts.typeRefs.StructuralTypeRef)
TypeRef(org.eclipse.n4js.ts.typeRefs.TypeRef)
TypeTypeRef(org.eclipse.n4js.ts.typeRefs.TypeTypeRef)
StaticBaseTypeRef(org.eclipse.n4js.ts.typeRefs.StaticBaseTypeRef)
ComposedTypeRef(org.eclipse.n4js.ts.typeRefs.ComposedTypeRef)
UnknownTypeRef(org.eclipse.n4js.ts.typeRefs.UnknownTypeRef)
StructuralTypingResult(org.eclipse.n4js.typesystem.StructuralTypingResult)
TaggedTemplateString(org.eclipse.n4js.n4JS.TaggedTemplateString)
RuleFailedException(org.eclipse.xsemantics.runtime.RuleFailedException)
Variance(org.eclipse.n4js.ts.types.util.Variance)
Result(org.eclipse.xsemantics.runtime.Result)
StructuralTypingResult(org.eclipse.n4js.typesystem.StructuralTypingResult)
ErrorInformation(org.eclipse.xsemantics.runtime.ErrorInformation)
TypeVariable(org.eclipse.n4js.ts.types.TypeVariable)
Wildcard(org.eclipse.n4js.ts.typeRefs.Wildcard)
PrimitiveType(org.eclipse.n4js.ts.types.PrimitiveType)
RuleEnvironment(org.eclipse.xsemantics.runtime.RuleEnvironment)
AnyType(org.eclipse.n4js.ts.types.AnyType)
Pair(org.eclipse.xtext.xbase.lib.Pair)
PropertyNameValuePair(org.eclipse.n4js.n4JS.PropertyNameValuePair)
TypeArgument(org.eclipse.n4js.ts.typeRefs.TypeArgument)
RuleFailedException(org.eclipse.xsemantics.runtime.RuleFailedException)
ParameterizedTypeRef(org.eclipse.n4js.ts.typeRefs.ParameterizedTypeRef)
Type(org.eclipse.n4js.ts.types.Type)
PrimitiveType(org.eclipse.n4js.ts.types.PrimitiveType)
VoidType(org.eclipse.n4js.ts.types.VoidType)
AnyType(org.eclipse.n4js.ts.types.AnyType)
ModuleNamespaceVirtualType(org.eclipse.n4js.ts.types.ModuleNamespaceVirtualType)
NullType(org.eclipse.n4js.ts.types.NullType)
UndefinedType(org.eclipse.n4js.ts.types.UndefinedType)
ContainerType(org.eclipse.n4js.ts.types.ContainerType)
TStructuralType(org.eclipse.n4js.ts.types.TStructuralType)
TEnum(org.eclipse.n4js.ts.types.TEnum)
EObject(org.eclipse.emf.ecore.EObject)
NullType(org.eclipse.n4js.ts.types.NullType)
UndefinedType(org.eclipse.n4js.ts.types.UndefinedType)
Example 14 with Pair
use of org.eclipse.xtext.xbase.lib.Pair in project n4js by eclipse.
the class ScriptApiTracker method _computeMissingApiGetterSetter.
/**
* Internal algorithm.
*/
private List<AccessorTuple> _computeMissingApiGetterSetter(TN4Classifier declaration, List<AccessorTuple> concreteAccessorTuples, Predicate<ProjectComparisonEntry> filterPredicate, boolean recursive) {
Optional<ProjectComparisonAdapter> optAdapt = firstProjectComparisonAdapter(declaration.eResource());
if (optAdapt.isPresent()) {
ProjectComparisonAdapter projectComparisonAdapter = optAdapt.get();
ProjectComparisonEntry compareEntry = projectComparisonAdapter.getEntryFor(EcoreUtil2.getContainerOfType(declaration, TModule.class));
ProjectComparisonEntry typeCompare = compareEntry.getChildForElementImpl(declaration);
if (typeCompare == null) {
return Collections.emptyList();
}
Predicate<ProjectComparisonEntry> filter = (pce -> (pce.getElementAPI() instanceof TGetter) || (pce.getElementAPI() instanceof TSetter));
filter = filter.and(pce -> pce.getElementImpl()[0] == null).and(filterPredicate);
ArrayList<ProjectComparisonEntry> collectedPCEofGetterOrSetter = new ArrayList<>();
Function<TN4Classifier, Consumer<? super ProjectComparisonEntry>> actionProvider = pivot -> pce -> {
// Get or Set ??
collectedPCEofGetterOrSetter.add(pce);
};
// recursive Extension will generate a stream of compareEntries.
if (recursive)
interfaceApiSupertypeWalker(filter, actionProvider, projectComparisonAdapter, (TN4Classifier) typeCompare.getElementAPI(), TN4Classifier.class);
// ----
/*-
Cases of the Implementation: A getter or setter can
- be given as AST (x)
- be missing (m)
- were not required by API (/)
So we have 3*3=9 cases:
get set
(x) (x) --> all fine, pair will be transpiled
(x) (m) --> code for getter will be transpiled, need to inject virtual setter code into existing tuple.
(x) (/) --> all fine, getter will be transpiled
(m) (x) --> code for setter will be transpiled, need to inject virtual getter code into existing tuple.
(m) (m) --> need to create virtual accessor tuple (similar to missing field) with setter & getter
(m) (/) --> need to create virtual accessor tuple with getter only
(/) (x) --> all fine
(/) (m) --> need to create virtual accessor tuple with setter only
(/) (/) --> all fine nothing to be done.
*/
List<ProjectComparisonEntry> getSetList;
if (recursive)
getSetList = collectedPCEofGetterOrSetter;
else
getSetList = typeCompare.allChildren().filter(pce -> (pce.getElementAPI() instanceof TGetter) || (pce.getElementAPI() instanceof TSetter)).filter(filterPredicate).collect(Collectors.toList());
HashMap<Pair<String, Boolean>, GetSetGroup> hmName2getset = new HashMap<>();
for (ProjectComparisonEntry pce : getSetList) {
TMember apiAsMember = ((TMember) pce.getElementAPI());
String name = apiAsMember.getName();
boolean staticCase = apiAsMember.isStatic();
Pair<String, Boolean> key = Pair.of(name, staticCase);
GetSetGroup group = hmName2getset.get(key);
if (group == null) {
group = new GetSetGroup(name, staticCase);
hmName2getset.put(key, group);
}
if (pce.getElementAPI() instanceof TGetter) {
// case getter:
TGetter apiGetter = (TGetter) pce.getElementAPI();
if (pce.getElementImpl(0) != null) {
// case (x) for getter-
group.getterIsInAST = true;
} else {
// case (m) for getter-
group.getterIsInAST = false;
group.getter = new VirtualApiTGetter(name, apiGetter);
}
} else if (pce.getElementAPI() instanceof TSetter) {
// case setter:
TSetter apiSetter = (TSetter) pce.getElementAPI();
if (pce.getElementImpl(0) != null) {
// case (x) for setter -
group.setterIsInAST = true;
} else {
// case (m) for setter:
group.setterIsInAST = false;
group.setter = new VirtualApiTSetter(name, apiSetter);
}
}
}
// go over the list of known AccessorTupels and enhance them by adding virtual things.
for (AccessorTuple conAccTupel : concreteAccessorTuples) {
GetSetGroup getset = hmName2getset.remove(Pair.of(conAccTupel.getName(), conAccTupel.isStatic()));
if (getset != null) {
// some missings found:
if (getset.hasGetter() && !getset.getterIsInAST && // could be mixed in by interface-default-impl different
conAccTupel.getGetter() == null) // to the intended API-path c.f. GHOLD-212
{
conAccTupel.setGetter(getset.getter);
}
if (getset.hasSetter() && !getset.setterIsInAST && // could be mixed in by interface-default-impl different
conAccTupel.getSetter() == null) // to the intended API-path c.f. GHOLD-212
{
conAccTupel.setSetter(getset.setter);
}
}
}
// remaining entries in hmName2getset need to translated into VirtualApiAccessors.
List<AccessorTuple> ret = new ArrayList<>();
for (GetSetGroup getset : hmName2getset.values()) {
VirtualApiAccessorTuple vAccessTupel = new VirtualApiAccessorTuple(getset.name, getset.staticCases);
if (getset.getter != null)
vAccessTupel.setGetter(getset.getter);
if (getset.setter != null)
vAccessTupel.setSetter(getset.setter);
ret.add(vAccessTupel);
}
return ret;
}
return emptyList();
}
Also used :
TSetter(org.eclipse.n4js.ts.types.TSetter)
ProjectComparisonEntry(org.eclipse.n4js.compare.ProjectComparisonEntry)
Inject(com.google.inject.Inject)
TClass(org.eclipse.n4js.ts.types.TClass)
ParameterizedTypeRef(org.eclipse.n4js.ts.typeRefs.ParameterizedTypeRef)
TSetter(org.eclipse.n4js.ts.types.TSetter)
Logger(org.apache.log4j.Logger)
TGetterImpl(org.eclipse.n4js.ts.types.impl.TGetterImpl)
TMethodImpl(org.eclipse.n4js.ts.types.impl.TMethodImpl)
Type(org.eclipse.n4js.ts.types.Type)
MemberList(org.eclipse.n4js.ts.types.util.MemberList)
N4InterfaceDeclaration(org.eclipse.n4js.n4JS.N4InterfaceDeclaration)
TFieldImpl(org.eclipse.n4js.ts.types.impl.TFieldImpl)
LinkedHashMultimap(com.google.common.collect.LinkedHashMultimap)
Collections.emptyList(java.util.Collections.emptyList)
Predicate(java.util.function.Predicate)
TField(org.eclipse.n4js.ts.types.TField)
EObject(org.eclipse.emf.ecore.EObject)
PROVIDES_DEFAULT_IMPLEMENTATION(org.eclipse.n4js.AnnotationDefinition.PROVIDES_DEFAULT_IMPLEMENTATION)
PROVIDES_INITIALZER(org.eclipse.n4js.AnnotationDefinition.PROVIDES_INITIALZER)
TMethod(org.eclipse.n4js.ts.types.TMethod)
Collectors(java.util.stream.Collectors)
TGetter(org.eclipse.n4js.ts.types.TGetter)
List(java.util.List)
Stream(java.util.stream.Stream)
TClassifier(org.eclipse.n4js.ts.types.TClassifier)
Resource(org.eclipse.emf.ecore.resource.Resource)
Optional(java.util.Optional)
Pair(org.eclipse.xtext.xbase.lib.Pair)
TypesFactory(org.eclipse.n4js.ts.types.TypesFactory)
Singleton(com.google.inject.Singleton)
HashMap(java.util.HashMap)
TypeUtils(org.eclipse.n4js.ts.utils.TypeUtils)
AccessorTuple(org.eclipse.n4js.ts.types.util.AccessorTuple)
Function(java.util.function.Function)
ArrayList(java.util.ArrayList)
HashSet(java.util.HashSet)
TModule(org.eclipse.n4js.ts.types.TModule)
TN4Classifier(org.eclipse.n4js.ts.types.TN4Classifier)
TInterface(org.eclipse.n4js.ts.types.TInterface)
ProjectCompareHelper(org.eclipse.n4js.compare.ProjectCompareHelper)
EcoreUtil2(org.eclipse.xtext.EcoreUtil2)
TAnnotableElement(org.eclipse.n4js.ts.types.TAnnotableElement)
MemberCollector(org.eclipse.n4js.utils.ContainerTypesHelper.MemberCollector)
LinkedHashSet(java.util.LinkedHashSet)
Iterator(java.util.Iterator)
TMember(org.eclipse.n4js.ts.types.TMember)
Script(org.eclipse.n4js.n4JS.Script)
Consumer(java.util.function.Consumer)
TypesPackage(org.eclipse.n4js.ts.types.TypesPackage)
AdapterImpl(org.eclipse.emf.common.notify.impl.AdapterImpl)
TSetterImpl(org.eclipse.n4js.ts.types.impl.TSetterImpl)
Collections(java.util.Collections)
HashMap(java.util.HashMap)
TGetter(org.eclipse.n4js.ts.types.TGetter)
ArrayList(java.util.ArrayList)
Consumer(java.util.function.Consumer)
AccessorTuple(org.eclipse.n4js.ts.types.util.AccessorTuple)
TModule(org.eclipse.n4js.ts.types.TModule)
ProjectComparisonEntry(org.eclipse.n4js.compare.ProjectComparisonEntry)
Pair(org.eclipse.xtext.xbase.lib.Pair)
TN4Classifier(org.eclipse.n4js.ts.types.TN4Classifier)
TMember(org.eclipse.n4js.ts.types.TMember)
Example 15 with Pair
use of org.eclipse.xtext.xbase.lib.Pair in project n4js by eclipse.
the class FlowgraphsXpectMethod method allMergeBranches.
/**
* This xpect method can evaluate all branches that are merged at the given node name.
*/
@ParameterParser(syntax = "('pleaseNeverUseThisParameterSinceItExistsOnlyToGetAReferenceOffset' arg1=OFFSET)?")
@Xpect
public void allMergeBranches(@N4JSCommaSeparatedValuesExpectation IN4JSCommaSeparatedValuesExpectation expectation, IEObjectCoveringRegion referenceOffset) {
N4JSFlowAnalyserDataRecorder.setEnabled(true);
GraphVisitor dfv = new DummyForwardVisitor();
GraphVisitor dbv = new DummyBackwardVisitor();
ControlFlowElement referenceCFE = getCFE(referenceOffset);
getFlowAnalyzer(referenceCFE).accept(dfv, dbv);
N4JSFlowAnalyserDataRecorder.setEnabled(false);
performBranchAnalysis(referenceOffset, null, referenceOffset);
List<String> edgeStrings = new LinkedList<>();
int groupIdx = 0;
List<Pair<Node, List<ControlFlowEdge>>> mergedEdges = N4JSFlowAnalyserDataRecorder.getMergedEdges();
for (Pair<Node, List<ControlFlowEdge>> pair : mergedEdges) {
Node startNode = pair.getKey();
List<ControlFlowEdge> edges = pair.getValue();
for (ControlFlowEdge edge : edges) {
String c = edge.start == startNode ? "B" : "F";
edgeStrings.add(c + groupIdx + ": " + edge.toString());
}
groupIdx++;
}
Collections.sort(edgeStrings);
expectation.assertEquals(edgeStrings);
}
Also used :
DummyBackwardVisitor(org.eclipse.n4js.flowgraphs.analysers.DummyBackwardVisitor)
GraphVisitor(org.eclipse.n4js.flowgraphs.analysis.GraphVisitor)
Node(org.eclipse.n4js.flowgraphs.model.Node)
DummyForwardVisitor(org.eclipse.n4js.flowgraphs.analysers.DummyForwardVisitor)
LinkedList(java.util.LinkedList)
ControlFlowEdge(org.eclipse.n4js.flowgraphs.model.ControlFlowEdge)
LinkedList(java.util.LinkedList)
List(java.util.List)
ControlFlowElement(org.eclipse.n4js.n4JS.ControlFlowElement)
Pair(org.eclipse.xtext.xbase.lib.Pair)
Xpect(org.eclipse.xpect.runner.Xpect)
ParameterParser(org.eclipse.xpect.parameter.ParameterParser)
Aggregations
Pair (org.eclipse.xtext.xbase.lib.Pair)67
StringConcatenation (org.eclipse.xtend2.lib.StringConcatenation)22
Test (org.junit.Test)15
Collection (java.util.Collection)11
List (java.util.List)11
ArrayList (java.util.ArrayList)9
AbstractHierarchyBuilderTest (org.eclipse.xtext.junit4.ide.AbstractHierarchyBuilderTest)9
Function1 (org.eclipse.xtext.xbase.lib.Functions.Function1)9
Map (java.util.Map)6
EObject (org.eclipse.emf.ecore.EObject)6
Resource (org.eclipse.emf.ecore.resource.Resource)6
AbstractElement (org.eclipse.xtext.AbstractElement)6
HashMap (java.util.HashMap)5
ParameterizedTypeRef (org.eclipse.n4js.ts.typeRefs.ParameterizedTypeRef)5
Type (org.eclipse.n4js.ts.types.Type)5
EList (org.eclipse.emf.common.util.EList)4
StringConcatenationClient (org.eclipse.xtend2.lib.StringConcatenationClient)4
UnorderedGroup (org.eclipse.xtext.UnorderedGroup)4
LinkedHashMap (java.util.LinkedHashMap)3
LinkedList (java.util.LinkedList)3
