Example 1 with StructuralTypingResult
use of org.eclipse.n4js.typesystem.StructuralTypingResult in project n4js by eclipse.
the class InternalTypeSystem method applyRuleSubtypeBoundThisTypeRef.
protected Result<Boolean> applyRuleSubtypeBoundThisTypeRef(final RuleEnvironment G, final RuleApplicationTrace _trace_, final BoundThisTypeRef left, final BoundThisTypeRef right) throws RuleFailedException {
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));
}
} else {
boolean _isUseSiteStructuralTyping_1 = left.isUseSiteStructuralTyping();
boolean _isUseSiteStructuralTyping_2 = right.isUseSiteStructuralTyping();
boolean _tripleEquals = (Boolean.valueOf(_isUseSiteStructuralTyping_1) == Boolean.valueOf(_isUseSiteStructuralTyping_2));
/* left.useSiteStructuralTyping === right.useSiteStructuralTyping */
if (!_tripleEquals) {
sneakyThrowRuleFailedException("left.useSiteStructuralTyping === right.useSiteStructuralTyping");
}
/* G |- left.actualThisTypeRef <: right.actualThisTypeRef */
ParameterizedTypeRef _actualThisTypeRef = left.getActualThisTypeRef();
ParameterizedTypeRef _actualThisTypeRef_1 = right.getActualThisTypeRef();
subtypeInternal(G, _trace_, _actualThisTypeRef, _actualThisTypeRef_1);
}
return new Result<Boolean>(true);
}
Also used :
ParameterizedTypeRef(org.eclipse.n4js.ts.typeRefs.ParameterizedTypeRef)
ErrorInformation(org.eclipse.xsemantics.runtime.ErrorInformation)
StructuralTypingResult(org.eclipse.n4js.typesystem.StructuralTypingResult)
EObject(org.eclipse.emf.ecore.EObject)
TaggedTemplateString(org.eclipse.n4js.n4JS.TaggedTemplateString)
Result(org.eclipse.xsemantics.runtime.Result)
StructuralTypingResult(org.eclipse.n4js.typesystem.StructuralTypingResult)
Example 2 with StructuralTypingResult
use of org.eclipse.n4js.typesystem.StructuralTypingResult 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)
Aggregations
EObject (org.eclipse.emf.ecore.EObject)2
TaggedTemplateString (org.eclipse.n4js.n4JS.TaggedTemplateString)2
ParameterizedTypeRef (org.eclipse.n4js.ts.typeRefs.ParameterizedTypeRef)2
StructuralTypingResult (org.eclipse.n4js.typesystem.StructuralTypingResult)2
ErrorInformation (org.eclipse.xsemantics.runtime.ErrorInformation)2
Result (org.eclipse.xsemantics.runtime.Result)2
PropertyNameValuePair (org.eclipse.n4js.n4JS.PropertyNameValuePair)1
BaseTypeRef (org.eclipse.n4js.ts.typeRefs.BaseTypeRef)1
BoundThisTypeRef (org.eclipse.n4js.ts.typeRefs.BoundThisTypeRef)1
ComposedTypeRef (org.eclipse.n4js.ts.typeRefs.ComposedTypeRef)1
ExistentialTypeRef (org.eclipse.n4js.ts.typeRefs.ExistentialTypeRef)1
FunctionTypeRef (org.eclipse.n4js.ts.typeRefs.FunctionTypeRef)1
StaticBaseTypeRef (org.eclipse.n4js.ts.typeRefs.StaticBaseTypeRef)1
StructuralTypeRef (org.eclipse.n4js.ts.typeRefs.StructuralTypeRef)1
ThisTypeRef (org.eclipse.n4js.ts.typeRefs.ThisTypeRef)1
TypeArgument (org.eclipse.n4js.ts.typeRefs.TypeArgument)1
TypeRef (org.eclipse.n4js.ts.typeRefs.TypeRef)1
TypeTypeRef (org.eclipse.n4js.ts.typeRefs.TypeTypeRef)1
UnknownTypeRef (org.eclipse.n4js.ts.typeRefs.UnknownTypeRef)1
Wildcard (org.eclipse.n4js.ts.typeRefs.Wildcard)1
