protected void computeTypes(Map<JvmIdentifiableElement, ResolvedTypes> preparedResolvedTypes, ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, EObject element) { if (element instanceof JvmDeclaredType) { _computeTypes(preparedResolvedTypes, resolvedTypes, featureScopeSession, (JvmDeclaredType) element); } else if (element instanceof JvmConstructor) { _computeTypes(preparedResolvedTypes, resolvedTypes, featureScopeSession, (JvmConstructor) element); } else if (element instanceof JvmField) { _computeTypes(preparedResolvedTypes, resolvedTypes, featureScopeSession, (JvmField) element); } else if (element instanceof JvmOperation) { _computeTypes(preparedResolvedTypes, resolvedTypes, featureScopeSession, (JvmOperation) element); } else { computeTypes(resolvedTypes, featureScopeSession, element); } }
protected void doPrepare(ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, JvmIdentifiableElement element, Map<JvmIdentifiableElement, ResolvedTypes> resolvedTypesByContext) { XExpression expression = getLogicalContainerProvider().getAssociatedExpression(element); if (expression != null) { if (!rootedInstances.contains(expression)) { throw new IllegalStateException("Expression not yet recorded: " + expression); } } if (element instanceof JvmDeclaredType) { _doPrepare(resolvedTypes, featureScopeSession, (JvmDeclaredType) element, resolvedTypesByContext); } else if (element instanceof JvmConstructor) { _doPrepare(resolvedTypes, featureScopeSession, (JvmConstructor) element, resolvedTypesByContext); } else if (element instanceof JvmField) { _doPrepare(resolvedTypes, featureScopeSession, (JvmField) element, resolvedTypesByContext); } else if (element instanceof JvmOperation) { _doPrepare(resolvedTypes, featureScopeSession, (JvmOperation) element, resolvedTypesByContext); } }
protected AbstractReentrantTypeReferenceProvider createTypeProvider(Map<JvmIdentifiableElement, ResolvedTypes> resolvedTypesByContext, ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, JvmMember member, boolean returnType) { XExpression expression = logicalContainerProvider.getAssociatedExpression(member); return createTypeProvider(resolvedTypesByContext, resolvedTypes, featureScopeSession, member, expression, returnType); }
protected void recordExpressions(JvmIdentifiableElement element) { XExpression expression = getLogicalContainerProvider().getAssociatedExpression(element); if (expression != null) { rootedInstances.add(expression); } if (element instanceof JvmDeclaredType) { _recordExpressions((JvmDeclaredType) element); } else if (element instanceof JvmExecutable) { _recordExpressions((JvmExecutable) element); } else if (element instanceof JvmFeature) { _recordExpressions((JvmFeature) element); } }
@Override protected void computeTypes(ResolvedTypes resolvedTypes, IFeatureScopeSession session) { EObject root = getRoot(); if (root instanceof JvmType) { Map<JvmIdentifiableElement, ResolvedTypes> preparedResolvedTypes = prepare(resolvedTypes, session); computeTypes(preparedResolvedTypes, resolvedTypes, session, root); } else { super.computeTypes(resolvedTypes, session); } }
@SuppressWarnings("unused") protected void _computeTypes(Map<JvmIdentifiableElement, ResolvedTypes> preparedResolvedTypes, ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, JvmOperation operation) { ResolvedTypes childResolvedTypes = preparedResolvedTypes.get(operation); if (childResolvedTypes == null) { if (preparedResolvedTypes.containsKey(operation)) return; throw new IllegalStateException("No resolved type found. Operation was: " + operation.getIdentifier()); } else { preparedResolvedTypes.put(operation, null); } OperationBodyComputationState state = new OperationBodyComputationState(childResolvedTypes, operation.isStatic() ? featureScopeSession : featureScopeSession.toInstanceContext(), operation); addExtensionProviders(state, operation.getParameters()); markComputing(operation.getReturnType()); try { state.computeTypes(); } finally { unmarkComputing(operation.getReturnType()); } computeAnnotationTypes(childResolvedTypes, featureScopeSession, operation); computeLocalTypes(preparedResolvedTypes, childResolvedTypes, featureScopeSession, operation); mergeChildTypes(childResolvedTypes); }
@SuppressWarnings("unused") protected void _computeTypes(Map<JvmIdentifiableElement, ResolvedTypes> preparedResolvedTypes, ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, JvmDeclaredType type) { ResolvedTypes childResolvedTypes = preparedResolvedTypes.get(type); if (childResolvedTypes == null) throw new IllegalStateException("No resolved type found. Type was: " + type.getIdentifier()); IFeatureScopeSession capturedState = LocalVariableCapturerImpl.findCapturedState(type); if (capturedState != null) { featureScopeSession = capturedState; } IFeatureScopeSession childSession = addThisAndSuper(featureScopeSession, childResolvedTypes.getReferenceOwner(), type); computeMemberTypes(preparedResolvedTypes, childResolvedTypes, childSession, type); computeAnnotationTypes(childResolvedTypes, featureScopeSession, type); mergeChildTypes(childResolvedTypes); }
@SuppressWarnings("unused") protected void _computeTypes(Map<JvmIdentifiableElement, ResolvedTypes> preparedResolvedTypes, ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, JvmConstructor constructor) { ResolvedTypes childResolvedTypes = preparedResolvedTypes.get(constructor); if (childResolvedTypes == null) { if (preparedResolvedTypes.containsKey(constructor)) return; throw new IllegalStateException("No resolved type found. Constructor was: " + constructor.getIdentifier()); } else { preparedResolvedTypes.put(constructor, null); } ConstructorBodyComputationState state = new ConstructorBodyComputationState(childResolvedTypes, featureScopeSession.toInstanceContext().toConstructorContext(), constructor); addExtensionProviders(state, constructor.getParameters()); state.computeTypes(); computeAnnotationTypes(childResolvedTypes, featureScopeSession, constructor); computeLocalTypes(preparedResolvedTypes, childResolvedTypes, featureScopeSession, constructor); mergeChildTypes(childResolvedTypes); }
protected void computeAnnotationTypes(ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, List<JvmAnnotationReference> annotations) { for(JvmAnnotationReference annotation: annotations) { EObject sourceElement = getSourceElement(annotation); if (sourceElement != annotation) { computeTypes(resolvedTypes, featureScopeSession, sourceElement); } else { for(JvmAnnotationValue value: annotation.getExplicitValues()) { if (value instanceof JvmCustomAnnotationValue) { JvmCustomAnnotationValue custom = (JvmCustomAnnotationValue) value; for(Object object: custom.getValues()) { if (object instanceof XExpression) { AnnotationValueTypeComputationState state = new AnnotationValueTypeComputationState(resolvedTypes, featureScopeSession, value, (XExpression) object); state.computeTypes(); } } } else if (value instanceof JvmAnnotationAnnotationValue) { computeAnnotationTypes(resolvedTypes, featureScopeSession, ((JvmAnnotationAnnotationValue) value).getValues()); } } } } }
protected void prepareMembers(ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, JvmDeclaredType type, Map<JvmIdentifiableElement, ResolvedTypes> resolvedTypesByType) { IFeatureScopeSession childSession = addExtensionsToMemberSession(resolvedTypes, featureScopeSession, type); StackedResolvedTypes childResolvedTypes = declareTypeParameters(resolvedTypes, type, resolvedTypesByType); JvmTypeReference superType = getExtendedClass(type); ITypeReferenceOwner referenceOwner = childResolvedTypes.getReferenceOwner(); if (superType != null) { LightweightTypeReference lightweightSuperType = referenceOwner.toLightweightTypeReference(superType); childResolvedTypes.reassignTypeWithoutMerge(superType.getType(), lightweightSuperType); /* * We use reassignType to make sure that the following works: * * StringList extends AbstractList<String> { * NestedIntList extends AbstractList<Integer> { * } * SubType extends StringList {} * } */ } LightweightTypeReference lightweightThisType = referenceOwner.toLightweightTypeReference(type); childResolvedTypes.reassignTypeWithoutMerge(type, lightweightThisType); List<JvmMember> members = type.getMembers(); int size = members.size(); for(int i = 0; i < size; i++) { doPrepare(childResolvedTypes, childSession, members.get(i), resolvedTypesByType); } }
if (featureScopeSession.isVisible(field) && seenNames.add(field.getSimpleName()) && isExtensionProvider(field)) { if (extensionProviders == null) { extensionProviders = Maps2.newLinkedHashMapWithExpectedSize(3); XAbstractFeatureCall extensionProvider = createExtensionProvider(thisFeature, field); LightweightTypeReference fieldType = resolvedTypes.getActualType(field); extensionProviders.put(extensionProvider, fieldType); JvmTypeReference superType = getExtendedClass(type); IFeatureScopeSession result = featureScopeSession; if (superType != null) { result = addExtensionFieldsToMemberSession(resolvedTypes, featureScopeSession, (JvmDeclaredType) superType.getType(), thisFeature, seenNames, seenTypes);
protected void computeLocalTypes( Map<JvmIdentifiableElement, ResolvedTypes> preparedResolvedTypes, ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, JvmFeature feature) { for(JvmGenericType localClass: feature.getLocalClasses()) { computeTypes(preparedResolvedTypes, resolvedTypes, featureScopeSession, localClass); } }
protected void computeMemberTypes(Map<JvmIdentifiableElement, ResolvedTypes> preparedResolvedTypes, ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, JvmDeclaredType type) { IFeatureScopeSession childSession = addExtensionsToMemberSession(resolvedTypes, featureScopeSession, type); List<JvmMember> members = type.getMembers(); for(int i = 0; i < members.size(); i++) { computeTypes(preparedResolvedTypes, resolvedTypes, childSession, members.get(i)); } }
@Override protected boolean isHandled(EObject context) { if (context instanceof XExpression) { return isHandled((XExpression)context); } if (context instanceof JvmIdentifiableElement) { return isHandled((JvmIdentifiableElement)context); } if (isPartOfExpressionTree(context)) { return isHandled((XExpression) context.eContainer()); } JvmIdentifiableElement logicalContainer = logicalContainerProvider.getNearestLogicalContainer(context); if (logicalContainer == null) return false; return isHandled(logicalContainer); }
@Override protected void _doPrepare(ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, JvmConstructor constructor, Map<JvmIdentifiableElement, ResolvedTypes> resolvedTypesByContext) { super._doPrepare(resolvedTypes, featureScopeSession, constructor, resolvedTypesByContext); doPrepareLocalTypes(resolvedTypesByContext.get(constructor), featureScopeSession, constructor, resolvedTypesByContext); }
@Override protected boolean isHandled(XExpression expression) { EObject root = getRoot(); if (root instanceof XtendTypeDeclaration) { return doIsHandled(root, expression); } return super.isHandled(expression); }
protected JvmTypeReference createComputedTypeReference( Map<JvmIdentifiableElement, ResolvedTypes> resolvedTypesByContext, ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, JvmMember member, /* @Nullable */ InferredTypeIndicator indicator, boolean returnType) { XComputedTypeReference result = getServices().getXtypeFactory().createXComputedTypeReference(); if (indicator == null || indicator.getExpression() == null) result.setTypeProvider(createTypeProvider(resolvedTypesByContext, resolvedTypes, featureScopeSession, member, returnType)); else result.setTypeProvider(createTypeProvider(resolvedTypesByContext, resolvedTypes, featureScopeSession, member, indicator.getExpression(), returnType)); // TODO do we need a lightweight computed type reference? // resolvedTypes.setType(member, result); return result; }
protected IFeatureScopeSession addThisAndSuper( IFeatureScopeSession session, ITypeReferenceOwner owner, JvmDeclaredType thisType, /* @Nullable */ JvmTypeReference superType, boolean addNestedTypes) { IFeatureScopeSession childSession = session; if (thisType.eContainer() != null) { if (thisType.isStatic()) { childSession = childSession.dropLocalElements(); } else { childSession = childSession.captureLocalElements(); } } if (superType != null && superType.getType() != null) { ImmutableMap.Builder<QualifiedName, JvmIdentifiableElement> builder = ImmutableMap.builder(); builder.put(IFeatureNames.THIS, thisType); builder.put(IFeatureNames.SUPER, superType.getType()); childSession = childSession.addLocalElements(builder.build(), owner); } else { childSession = childSession.addLocalElement(IFeatureNames.THIS, thisType, owner); } childSession = addThisTypeToStaticScope(childSession, thisType); if (addNestedTypes) childSession = childSession.addNestedTypesToScope(thisType); return childSession; }
protected JvmTypeReference doGetTypeReferenceWithCurrentTypeResolver() { LightweightTypeReference actualType = returnType ? resolvedTypes.getReturnType(expression) : resolvedTypes.getActualType(expression); if (actualType == null) { computeTypes(resolvedTypesByContext, resolvedTypes, session, member); actualType = returnType ? resolvedTypes.getExpectedReturnType(expression) : resolvedTypes.getExpectedType(expression); if (actualType == null) actualType = returnType ? resolvedTypes.getReturnType(expression) : resolvedTypes.getActualType(expression); } if (actualType == null) return null; return toJavaCompliantTypeReference(convertLocalType(actualType), session); }
protected void _doPrepare(ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, JvmDeclaredType type, Map<JvmIdentifiableElement, ResolvedTypes> resolvedTypesByType) { IFeatureScopeSession childSession = addThisAndSuper(featureScopeSession, resolvedTypes.getReferenceOwner(), type); prepareMembers(resolvedTypes, childSession, type, resolvedTypesByType); }