use of org.eclipse.n4js.ts.typeRefs.ParameterizedTypeRef in project n4js by eclipse.
the class MemberRedefinitionUtils method getFilledClass.
/**
* Returns the class which is filled by the given static polyfill class definition.
*
* Returns {@code null} if staticPolyfillDefinition isn't a valid static polyfill class definition.
*/
public static TClass getFilledClass(N4ClassDefinition staticPolyfillDefinition) {
if (!(staticPolyfillDefinition.getDefinedType() instanceof TClassifier)) {
return null;
}
TClassifier classifier = (TClassifier) staticPolyfillDefinition.getDefinedType();
if (!classifier.isStaticPolyfill()) {
return null;
}
ParameterizedTypeRef superClassTypeRef = Iterables.getFirst(classifier.getSuperClassifierRefs(), null);
if (null == superClassTypeRef) {
return null;
}
Type superClassType = superClassTypeRef.getDeclaredType();
if (superClassType instanceof TClass && ((TClass) superClassType).getContainingModule().isStaticPolyfillAware()) {
return (TClass) superClassType;
} else {
return null;
}
}
use of org.eclipse.n4js.ts.typeRefs.ParameterizedTypeRef in project n4js by eclipse.
the class BuiltInTypeScopeTest method testParsing.
@SuppressWarnings("javadoc")
@Test
public void testParsing() throws Exception {
String content = "var name: any = 'global'";
Script result = parseHelper.parse(content);
Assert.assertNotNull(result);
Assert.assertEquals(1, result.getScriptElements().size());
ScriptElement elem = result.getScriptElements().get(0);
Assert.assertTrue(elem instanceof VariableStatement);
VariableStatement stmt = (VariableStatement) elem;
VariableDeclaration varDecl = stmt.getVarDecl().get(0);
ParameterizedTypeRef typeRef = (ParameterizedTypeRef) varDecl.getDeclaredTypeRef();
Assert.assertFalse("Proxy URI: " + ((InternalEObject) typeRef.getDeclaredType()).eProxyURI(), typeRef.getDeclaredType().eIsProxy());
}
use of org.eclipse.n4js.ts.typeRefs.ParameterizedTypeRef in project n4js by eclipse.
the class InternalTypeSystem method applyRuleTypeCallExpression.
protected Result<TypeRef> applyRuleTypeCallExpression(final RuleEnvironment G, final RuleApplicationTrace _trace_, final ParameterizedCallExpression expr) throws RuleFailedException {
// output parameter
TypeRef T = null;
/* G |- expr.target : var TypeRef targetTypeRef */
Expression _target = expr.getTarget();
TypeRef targetTypeRef = null;
Result<TypeRef> result = typeInternal(G, _trace_, _target);
checkAssignableTo(result.getFirst(), TypeRef.class);
targetTypeRef = (TypeRef) result.getFirst();
if ((targetTypeRef instanceof FunctionTypeExprOrRef)) {
final FunctionTypeExprOrRef F = ((FunctionTypeExprOrRef) targetTypeRef);
final TFunction tFunction = F.getFunctionType();
/* { val inferring = env(G, GUARD_TYPE_CALL_EXPRESSION -> expr, TypeRef) G |- inferring ~> T } or { val G2 = G.wrap; G2.add(GUARD_TYPE_CALL_EXPRESSION -> expr, F.returnTypeRef) if(expr.eContainer instanceof AwaitExpression && expr.eContainmentFeature === N4JSPackage.eINSTANCE.getAwaitExpression_Expression() && tFunction!==null && AnnotationDefinition.PROMISIFIABLE.hasAnnotation(tFunction)) { T = promisifyHelper.extractPromisifiedReturnType(expr); } else { T = F.returnTypeRef ?: G.anyTypeRef; } typeSystemHelper.addSubstitutions(G2, expr, targetTypeRef); G2 |- T ~> T T = versionResolver.resolveVersion(T, F); if (T instanceof BoundThisTypeRef && !(expr.receiver instanceof ThisLiteral || expr.receiver instanceof SuperLiteral)) { G2 |~ T /\ T } } */
{
RuleFailedException previousFailure = null;
try {
Pair<String, ParameterizedCallExpression> _mappedTo = Pair.<String, ParameterizedCallExpression>of(RuleEnvironmentExtensions.GUARD_TYPE_CALL_EXPRESSION, expr);
final TypeRef inferring = this.<TypeRef>env(G, _mappedTo, TypeRef.class);
/* G |- inferring ~> T */
Result<TypeArgument> result_1 = substTypeVariablesInternal(G, _trace_, inferring);
checkAssignableTo(result_1.getFirst(), TypeRef.class);
T = (TypeRef) result_1.getFirst();
} catch (Exception e) {
previousFailure = extractRuleFailedException(e);
final RuleEnvironment G2 = RuleEnvironmentExtensions.wrap(G);
Pair<String, ParameterizedCallExpression> _mappedTo_1 = Pair.<String, ParameterizedCallExpression>of(RuleEnvironmentExtensions.GUARD_TYPE_CALL_EXPRESSION, expr);
boolean _add = G2.add(_mappedTo_1, F.getReturnTypeRef());
/* G2.add(GUARD_TYPE_CALL_EXPRESSION -> expr, F.returnTypeRef) */
if (!_add) {
sneakyThrowRuleFailedException("G2.add(GUARD_TYPE_CALL_EXPRESSION -> expr, F.returnTypeRef)");
}
if (((((expr.eContainer() instanceof AwaitExpression) && (expr.eContainmentFeature() == N4JSPackage.eINSTANCE.getAwaitExpression_Expression())) && (tFunction != null)) && AnnotationDefinition.PROMISIFIABLE.hasAnnotation(tFunction))) {
T = this.promisifyHelper.extractPromisifiedReturnType(expr);
} else {
TypeRef _elvis = null;
TypeRef _returnTypeRef = F.getReturnTypeRef();
if (_returnTypeRef != null) {
_elvis = _returnTypeRef;
} else {
ParameterizedTypeRef _anyTypeRef = RuleEnvironmentExtensions.anyTypeRef(G);
_elvis = _anyTypeRef;
}
T = _elvis;
}
this.typeSystemHelper.addSubstitutions(G2, expr, targetTypeRef);
/* G2 |- T ~> T */
Result<TypeArgument> result_2 = substTypeVariablesInternal(G2, _trace_, T);
checkAssignableTo(result_2.getFirst(), TypeRef.class);
T = (TypeRef) result_2.getFirst();
T = this.versionResolver.<TypeRef, FunctionTypeExprOrRef>resolveVersion(T, F);
if (((T instanceof BoundThisTypeRef) && (!((expr.getReceiver() instanceof ThisLiteral) || (expr.getReceiver() instanceof SuperLiteral))))) {
/* G2 |~ T /\ T */
Result<TypeRef> result_3 = upperBoundInternal(G2, _trace_, T);
checkAssignableTo(result_3.getFirst(), TypeRef.class);
T = (TypeRef) result_3.getFirst();
}
}
}
} else {
Type _declaredType = null;
if (targetTypeRef != null) {
_declaredType = targetTypeRef.getDeclaredType();
}
TObjectPrototype _functionType = RuleEnvironmentExtensions.functionType(G);
boolean _tripleEquals = (_declaredType == _functionType);
if (_tripleEquals) {
T = RuleEnvironmentExtensions.anyTypeRef(G);
} else {
boolean _isDynamic = targetTypeRef.isDynamic();
if (_isDynamic) {
T = RuleEnvironmentExtensions.anyTypeRefDynamic(G);
} else {
T = TypeRefsFactory.eINSTANCE.createUnknownTypeRef();
}
}
}
return new Result<TypeRef>(T);
}
use of org.eclipse.n4js.ts.typeRefs.ParameterizedTypeRef in project n4js by eclipse.
the class InternalTypeSystem method expectedTypeInImpl.
protected Result<TypeRef> expectedTypeInImpl(final RuleEnvironment G, final RuleApplicationTrace _trace_, final BinaryLogicalExpression e, final Expression expression) throws RuleFailedException {
try {
final RuleApplicationTrace _subtrace_ = newTrace(_trace_);
final Result<TypeRef> _result_ = applyRuleExpectedTypeInBinaryLogicalExpression(G, _subtrace_, e, expression);
addToTrace(_trace_, new Provider<Object>() {
public Object get() {
return ruleName("expectedTypeInBinaryLogicalExpression") + stringRepForEnv(G) + " |- " + stringRep(e) + " |> " + stringRep(expression) + " : " + stringRep(_result_.getFirst());
}
});
addAsSubtrace(_trace_, _subtrace_);
return _result_;
} catch (Exception e_applyRuleExpectedTypeInBinaryLogicalExpression) {
expectedTypeInThrowException(ruleName("expectedTypeInBinaryLogicalExpression") + stringRepForEnv(G) + " |- " + stringRep(e) + " |> " + stringRep(expression) + " : " + "ParameterizedTypeRef", EXPECTEDTYPEINBINARYLOGICALEXPRESSION, e_applyRuleExpectedTypeInBinaryLogicalExpression, e, expression, new ErrorInformation[] { new ErrorInformation(e), new ErrorInformation(expression) });
return null;
}
}
use of org.eclipse.n4js.ts.typeRefs.ParameterizedTypeRef in project n4js by eclipse.
the class InternalTypeSystem method applyRuleSubstTypeVariablesInParameterizedTypeRef.
protected Result<TypeArgument> applyRuleSubstTypeVariablesInParameterizedTypeRef(final RuleEnvironment G, final RuleApplicationTrace _trace_, final ParameterizedTypeRef typeRef) throws RuleFailedException {
// output parameter
TypeRef result = null;
result = typeRef;
Type _declaredType = typeRef.getDeclaredType();
if ((_declaredType instanceof TypeVariable)) {
Type _declaredType_1 = typeRef.getDeclaredType();
final TypeVariable typeVar = ((TypeVariable) _declaredType_1);
/* { var temp = env(G, typeVar, TypeRef) if (typeRef instanceof ParameterizedTypeRefStructural) { if (temp instanceof ParameterizedTypeRef) { var ptrs = TypeUtils.copyToParameterizedTypeRefStructural(temp); ptrs.setTypingStrategy(typeRef.getTypingStrategy()); temp = ptrs; } } val tempDeclaredType = temp.declaredType if (typeVar !== tempDeclaredType && (TypeUtils.isOrContainsRefToTypeVar(temp) || (tempDeclaredType !== null && tempDeclaredType.generic)) && G.get(GUARD_SUBST_TYPE_VARS -> temp) === null) { val G2 = G.wrap; G2.add(GUARD_SUBST_TYPE_VARS -> temp, Boolean.TRUE) G2 |- temp ~> result result = TypeUtils.copy(result); } else { result = TypeUtils.copy(temp); } TypeUtils.copyTypeModifiers(result, typeRef) } or { val List<TypeRef> l_raw = env(G, typeVar, List) val l = newArrayList; for(var i=0;i<l_raw.size;i++) { val temp = l_raw.get(i); val tempDeclaredType = temp.declaredType; if(typeVar !== tempDeclaredType && (TypeUtils.isOrContainsRefToTypeVar(temp) || (tempDeclaredType !== null && tempDeclaredType.generic)) && G.get(GUARD_SUBST_TYPE_VARS -> temp) === null) { val G2 = G.wrap; G2.add(GUARD_SUBST_TYPE_VARS -> temp, Boolean.TRUE) G2 |- temp ~> var TypeRef tempResult tempResult = TypeUtils.copy(tempResult); l += tempResult; } else { l += TypeUtils.copy(temp); } } result = if(typeVar.declaredCovariant) { typeSystemHelper.createIntersectionType(G,l) } else if(typeVar.declaredContravariant) { typeSystemHelper.createUnionType(G,l) } else { G.addInconsistentSubstitutions(typeVar, l); TypeRefsFactory.eINSTANCE.createUnknownTypeRef }; TypeUtils.copyTypeModifiers(result, typeRef) } or { } */
{
RuleFailedException previousFailure = null;
try {
TypeRef temp = this.<TypeRef>env(G, typeVar, TypeRef.class);
if ((typeRef instanceof ParameterizedTypeRefStructural)) {
if ((temp instanceof ParameterizedTypeRef)) {
ParameterizedTypeRefStructural ptrs = TypeUtils.copyToParameterizedTypeRefStructural(((ParameterizedTypeRef) temp));
ptrs.setTypingStrategy(((ParameterizedTypeRefStructural) typeRef).getTypingStrategy());
temp = ptrs;
}
}
final Type tempDeclaredType = temp.getDeclaredType();
if ((((typeVar != tempDeclaredType) && (TypeUtils.isOrContainsRefToTypeVar(temp) || ((tempDeclaredType != null) && tempDeclaredType.isGeneric()))) && (G.get(Pair.<String, TypeRef>of(RuleEnvironmentExtensions.GUARD_SUBST_TYPE_VARS, temp)) == null))) {
final RuleEnvironment G2 = RuleEnvironmentExtensions.wrap(G);
Pair<String, TypeRef> _mappedTo = Pair.<String, TypeRef>of(RuleEnvironmentExtensions.GUARD_SUBST_TYPE_VARS, temp);
boolean _add = G2.add(_mappedTo, Boolean.TRUE);
/* G2.add(GUARD_SUBST_TYPE_VARS -> temp, Boolean.TRUE) */
if (!_add) {
sneakyThrowRuleFailedException("G2.add(GUARD_SUBST_TYPE_VARS -> temp, Boolean.TRUE)");
}
/* G2 |- temp ~> result */
Result<TypeArgument> result_1 = substTypeVariablesInternal(G2, _trace_, temp);
checkAssignableTo(result_1.getFirst(), TypeRef.class);
result = (TypeRef) result_1.getFirst();
result = TypeUtils.<TypeRef>copy(result);
} else {
result = TypeUtils.<TypeRef>copy(temp);
}
TypeUtils.copyTypeModifiers(result, typeRef);
} catch (Exception e) {
previousFailure = extractRuleFailedException(e);
/* { val List<TypeRef> l_raw = env(G, typeVar, List) val l = newArrayList; for(var i=0;i<l_raw.size;i++) { val temp = l_raw.get(i); val tempDeclaredType = temp.declaredType; if(typeVar !== tempDeclaredType && (TypeUtils.isOrContainsRefToTypeVar(temp) || (tempDeclaredType !== null && tempDeclaredType.generic)) && G.get(GUARD_SUBST_TYPE_VARS -> temp) === null) { val G2 = G.wrap; G2.add(GUARD_SUBST_TYPE_VARS -> temp, Boolean.TRUE) G2 |- temp ~> var TypeRef tempResult tempResult = TypeUtils.copy(tempResult); l += tempResult; } else { l += TypeUtils.copy(temp); } } result = if(typeVar.declaredCovariant) { typeSystemHelper.createIntersectionType(G,l) } else if(typeVar.declaredContravariant) { typeSystemHelper.createUnionType(G,l) } else { G.addInconsistentSubstitutions(typeVar, l); TypeRefsFactory.eINSTANCE.createUnknownTypeRef }; TypeUtils.copyTypeModifiers(result, typeRef) } or { } */
{
try {
final List<TypeRef> l_raw = this.<List>env(G, typeVar, List.class);
final ArrayList<TypeRef> l = CollectionLiterals.<TypeRef>newArrayList();
for (int i = 0; (i < l_raw.size()); i++) {
final TypeRef temp_1 = l_raw.get(i);
final Type tempDeclaredType_1 = temp_1.getDeclaredType();
if ((((typeVar != tempDeclaredType_1) && (TypeUtils.isOrContainsRefToTypeVar(temp_1) || ((tempDeclaredType_1 != null) && tempDeclaredType_1.isGeneric()))) && (G.get(Pair.<String, TypeRef>of(RuleEnvironmentExtensions.GUARD_SUBST_TYPE_VARS, temp_1)) == null))) {
final RuleEnvironment G2_1 = RuleEnvironmentExtensions.wrap(G);
Pair<String, TypeRef> _mappedTo_1 = Pair.<String, TypeRef>of(RuleEnvironmentExtensions.GUARD_SUBST_TYPE_VARS, temp_1);
boolean _add_1 = G2_1.add(_mappedTo_1, Boolean.TRUE);
/* G2.add(GUARD_SUBST_TYPE_VARS -> temp, Boolean.TRUE) */
if (!_add_1) {
sneakyThrowRuleFailedException("G2.add(GUARD_SUBST_TYPE_VARS -> temp, Boolean.TRUE)");
}
/* G2 |- temp ~> var TypeRef tempResult */
TypeRef tempResult = null;
Result<TypeArgument> result_2 = substTypeVariablesInternal(G2_1, _trace_, temp_1);
checkAssignableTo(result_2.getFirst(), TypeRef.class);
tempResult = (TypeRef) result_2.getFirst();
tempResult = TypeUtils.<TypeRef>copy(tempResult);
/* l += tempResult */
if (!l.add(tempResult)) {
sneakyThrowRuleFailedException("l += tempResult");
}
} else {
TypeRef _copy = TypeUtils.<TypeRef>copy(temp_1);
/* l += TypeUtils.copy(temp) */
if (!l.add(_copy)) {
sneakyThrowRuleFailedException("l += TypeUtils.copy(temp)");
}
}
}
TypeRef _xifexpression = null;
boolean _isDeclaredCovariant = typeVar.isDeclaredCovariant();
if (_isDeclaredCovariant) {
_xifexpression = this.typeSystemHelper.createIntersectionType(G, ((TypeRef[]) Conversions.unwrapArray(l, TypeRef.class)));
} else {
TypeRef _xifexpression_1 = null;
boolean _isDeclaredContravariant = typeVar.isDeclaredContravariant();
if (_isDeclaredContravariant) {
_xifexpression_1 = this.typeSystemHelper.createUnionType(G, ((TypeRef[]) Conversions.unwrapArray(l, TypeRef.class)));
} else {
UnknownTypeRef _xblockexpression = null;
{
RuleEnvironmentExtensions.addInconsistentSubstitutions(G, typeVar, l);
_xblockexpression = (TypeRefsFactory.eINSTANCE.createUnknownTypeRef());
}
_xifexpression_1 = _xblockexpression;
}
_xifexpression = _xifexpression_1;
}
result = _xifexpression;
TypeUtils.copyTypeModifiers(result, typeRef);
} catch (Exception e_1) {
previousFailure = extractRuleFailedException(e_1);
}
}
}
}
}
boolean _and = false;
Type _declaredType_2 = null;
if (typeRef != null) {
_declaredType_2 = typeRef.getDeclaredType();
}
boolean _tripleNotEquals = (_declaredType_2 != null);
if (!_tripleNotEquals) {
_and = false;
} else {
boolean _isGeneric = typeRef.getDeclaredType().isGeneric();
_and = _isGeneric;
}
if (_and) {
final int len = typeRef.getTypeArgs().size();
boolean haveSubstitution = false;
final TypeArgument[] argsChanged = new TypeArgument[len];
for (int i = 0; (i < len); i++) {
final TypeArgument arg = typeRef.getTypeArgs().get(i);
/* G |- arg ~> var TypeArgument argSubst */
TypeArgument argSubst = null;
Result<TypeArgument> result_2 = substTypeVariablesInternal(G, _trace_, arg);
checkAssignableTo(result_2.getFirst(), TypeArgument.class);
argSubst = (TypeArgument) result_2.getFirst();
if ((argSubst != arg)) {
argsChanged[i] = argSubst;
haveSubstitution = true;
}
}
if (haveSubstitution) {
if ((result == typeRef)) {
result = TypeUtils.<ParameterizedTypeRef>copy(typeRef);
}
for (int i = 0; (i < len); i++) {
final TypeArgument argCh = argsChanged[i];
if ((argCh != null)) {
result.getTypeArgs().set(i, argCh);
}
}
}
}
if ((result instanceof StructuralTypeRef)) {
result = this.typeSystemHelper.substTypeVariablesInStructuralMembers(G, ((StructuralTypeRef) result));
}
return new Result<TypeArgument>(result);
}
Aggregations