protected ExpressionTypeComputationState createExpressionComputationState(XExpression expression, StackedResolvedTypes typeResolution) { return new ExpressionTypeComputationState(typeResolution, featureScopeSession, this, expression); }
protected void applyType() { state.acceptActualType(state.getReferenceOwner().newUnknownTypeReference(), ConformanceFlags.CHECKED_SUCCESS); }
@Override public void applyToComputationState() { state.acceptCandidate(implicit, this); getState().markAsRefinedTypeIfNecessary(this); }
@Override public TypeComputationStateWithExpectation withExpectation(/* @Nullable */ LightweightTypeReference expectation) { return new ExpressionTypeComputationStateWithExpectation(getResolvedTypes(), getFeatureScopeSession(), this, expectation); }
if (feature instanceof JvmType) { QualifiedName featureName = description.getName(); if (!getState().isInstanceContext()) { if (!(SELF.equals(featureName))) { String message = String.format("Cannot use %s in a static context", featureName); XAbstractFeatureCall target = (XAbstractFeatureCall) memberFeatureCall.getMemberCallTarget(); final JvmType referencedType = (JvmType) target.getFeature(); List<JvmDeclaredType> enclosingTypes = getState().getFeatureScopeSession().getEnclosingTypes(); if (SUPER.equals(featureName) && referencedType instanceof JvmGenericType && ((JvmGenericType) referencedType).isInterface() && !enclosingTypes.isEmpty()) { List<JvmDeclaredType> enclosingTypes = getState().getFeatureScopeSession().getEnclosingTypes(); JvmDeclaredType declaringType = null; if (!enclosingTypes.isEmpty()) declaringType = enclosingTypes.get(0); if (declaringType instanceof JvmGenericType && ((JvmGenericType) declaringType).isInterface()) { if (!getState().isIgnored(IssueCodes.UNQUALIFIED_SUPER_CALL)) { AbstractDiagnostic diagnostic = new EObjectDiagnosticImpl(getSeverity(IssueCodes.UNQUALIFIED_SUPER_CALL), IssueCodes.UNQUALIFIED_SUPER_CALL, XClosure closure = EcoreUtil2.getContainerOfType(featureCall, XClosure.class); if (closure != null) { EObject typeSource = getState().getReferenceOwner().getServices().getJvmModelAssociations().getPrimarySourceElement(declaringType); if (typeSource != null && EcoreUtil.isAncestor(typeSource, closure)) { AbstractDiagnostic diagnostic = new EObjectDiagnosticImpl(Severity.ERROR, XVariableDeclaration casted = (XVariableDeclaration) feature; if (casted.isWriteable()) {
protected LightweightTypeReference getAsClassLiteral(final JvmIdentifiableElement feature) { if (feature instanceof JvmType) { final ITypeReferenceOwner owner = state.getReferenceOwner(); return owner.newReferenceTo(Class.class, new TypeReferenceInitializer<ParameterizedTypeReference>() { @Override public LightweightTypeReference enhance(ParameterizedTypeReference reference) { LightweightTypeReference argumentType = owner.newParameterizedTypeReference((JvmType) feature); if (argumentType.isPrimitiveVoid()) { argumentType = owner.newReferenceTo(Void.class); } else { argumentType = argumentType.getWrapperTypeIfPrimitive(); } reference.addTypeArgument(argumentType); return reference; } }); } throw new IllegalArgumentException(String.valueOf(feature)); }
protected LightweightTypeReference getActualType(/* @Nullable */ XExpression expression) { if (expression == null) return null; return state.getResolvedTypes().getActualType(expression); }
protected LightweightTypeReference getDeclaredType(JvmIdentifiableElement feature) { LightweightTypeReference result = state.getResolvedTypes().getActualType(feature); if (result == null) { return getState().getReferenceOwner().newAnyTypeReference(); } return result; }
XExpression receiver = getImplicitReceiver(); if (receiver != null) { ResolvedTypes resolvedTypes = getState().getResolvedTypes(); LightweightTypeReference receiverType = getImplicitReceiverType(); if (receiverType == null) { resolvedTypes.acceptType(receiver, expectation, receiverType.copyInto(resolvedTypes.getReferenceOwner()), false, ConformanceFlags.UNCHECKED); getState().markAsRefinedTypeIfNecessary(this); discardRefinementTypeIfReassigned(); LightweightTypeReference expectedReceiverType = expectedReceiverTypeWrapper.get(); if (expectedReceiverType != null) { getState().refineExpectedType(actualReceiver, expectedReceiverType);
@Override public boolean validate(IAcceptor<? super AbstractDiagnostic> result) { if (!getState().isInstanceContext()) { JvmIdentifiableElement implicitFeature = getFeature(); if (implicitFeature instanceof JvmType) { JvmIdentifiableElement feature = getState().getResolvedTypes().getLinkedFeature(getOwner()); if (feature == null || feature.eIsProxy() || !(feature instanceof JvmFeature)) return true; String message = "Cannot make an implicit reference to this from a static context"; AbstractDiagnostic diagnostic = new EObjectDiagnosticImpl(Severity.ERROR, IssueCodes.STATIC_ACCESS_TO_INSTANCE_MEMBER, message, getOwner(), XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE, -1, null); result.accept(diagnostic); return false; } } return super.validate(result); }
protected boolean validateUnhandledExceptions(JvmExecutable executable, IAcceptor<? super AbstractDiagnostic> result) { TypeParameterSubstitutor<?> substitutor = createArgumentTypeSubstitutor(); List<LightweightTypeReference> unhandledExceptions = null; List<LightweightTypeReference> expectedExceptions = getState().getExpectedExceptions(); ITypeReferenceOwner referenceOwner = getState().getReferenceOwner(); outer: for(JvmTypeReference typeReference: executable.getExceptions()) { LightweightTypeReference exception = referenceOwner.toLightweightTypeReference(typeReference);
protected ExpressionAwareStackedResolvedTypes doComputeTypes(XExpression expression) { ExpressionAwareStackedResolvedTypes stackedResolvedTypes = pushTypes(expression); ExpressionTypeComputationState state = createExpressionComputationState(expression, stackedResolvedTypes); stackedResolvedTypes.addExpressionScope(expression, state.getFeatureScopeSession(), IExpressionScope.Anchor.BEFORE); getResolver().getTypeComputer().computeTypes(expression, state); stackedResolvedTypes.prepareMergeIntoParent(); if (stackedResolvedTypes.doGetTypeData(expression) == null) { state.acceptActualType(stackedResolvedTypes.getReferenceOwner().newAnyTypeReference()); } stackedResolvedTypes.addExpressionScope(expression, getFeatureScopeSession(), IExpressionScope.Anchor.AFTER); return stackedResolvedTypes; }
@Override protected LightweightTypeReference getDeclaredType(JvmIdentifiableElement feature) { if (feature instanceof JvmConstructor) { return getState().getReferenceOwner().toLightweightTypeReference(getState().getTypeReferences().getTypeForName(Void.TYPE, feature));
@Override public boolean validate(IAcceptor<? super AbstractDiagnostic> result) { JvmIdentifiableElement implicitFeature = getFeature(); if (implicitFeature instanceof XVariableDeclaration) { XVariableDeclaration casted = (XVariableDeclaration) implicitFeature; if (casted.isWriteable()) { String message = getState().getResolver().getInvalidWritableVariableAccessMessage(casted, getFeatureCall(), getState().getResolvedTypes()); if (message != null) { AbstractDiagnostic diagnostic = new EObjectDiagnosticImpl(Severity.ERROR, IssueCodes.INVALID_MUTABLE_VARIABLE_ACCESS, message, getOwner(), XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE, -1, null); result.accept(diagnostic); return false; } } if (EcoreUtil.isAncestor(casted, getFeatureCall())) { String message = String.format("The implicitly referenced variable %s may not have been initialized", implicitFeature.getSimpleName()); AbstractDiagnostic diagnostic = new EObjectDiagnosticImpl(Severity.ERROR, IssueCodes.ILLEGAL_FORWARD_REFERENCE, message, getOwner(), XbasePackage.Literals.XABSTRACT_FEATURE_CALL__FEATURE, -1, null); result.accept(diagnostic); return false; } } return true; }
@Override protected LightweightTypeReference acceptType(XExpression expression, ResolvedTypes resolvedTypes, AbstractTypeExpectation expectation, LightweightTypeReference type, boolean returnType, int flags) { if (expression != this.expression) { LightweightTypeReference result = resolvedTypes.acceptType(this.expression, expectation, type, returnType, flags); getParent().acceptType(this.expression, resolvedTypes, expectation, type, returnType, flags); return result; } return getParent().acceptType(expression, resolvedTypes, expectation, type, returnType, flags); }
protected boolean isInstanceContext() { return getFeatureScopeSession().isInstanceContext(); }
protected Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> initializeTypeParameterMapping() { Map<JvmTypeParameter, LightweightMergedBoundTypeArgument> typeParameterMapping; state.acceptCandidate(expression, this); List<JvmTypeParameter> declaredTypeParameters = getDeclaredTypeParameters(); if (declaredTypeParameters.isEmpty()) { typeParameterMapping = Collections.emptyMap(); } else { typeParameterMapping = initializeTypeParameterMapping(declaredTypeParameters); } return typeParameterMapping; }
protected void initializeArgumentTypeComputation() { if (arguments != null) return; getTypeParameterMapping(); // trigger lazy init arguments = state.getResolver().getExpressionArgumentFactory().createExpressionArguments(expression, this); }
protected void discardRefinementTypeIfReassigned() { if (mustDiscardRefinement()) { getState().discardReassignedTypes(getFeature()); } }
@Override protected void applyType() { JvmType type = (JvmType) getFeature(); if (type == null || type.eIsProxy()) { throw new IllegalStateException(); } ITypeReferenceOwner referenceOwner = getResolvedTypes().getReferenceOwner(); ParameterizedTypeReference result = referenceOwner.newParameterizedTypeReference(type); for(LightweightTypeReference typeArgument: getTypeArguments()) { result.addTypeArgument(typeArgument); } getState().acceptActualType(result); }