protected void addOperationCandidates(final ResolvedFeatures resolvedFeatures, final IVisibilityHelper visibilityHelper, final List<IResolvedExecutable> result) { List<IResolvedOperation> allOperations = resolvedFeatures.getAllOperations(); LightweightTypeReference inferredType = resolvedFeatures.getType(); for (final IResolvedOperation operation : allOperations) { boolean _isCandidate = this.isCandidate(inferredType, operation, visibilityHelper); if (_isCandidate) { result.add(operation); } } }
@Override public List<IResolvedOperation> apply(String erasedSignature) { return resolvedFeatures.getDeclaredOperations(erasedSignature); } }, flaggedOperations);
/** * Returns the resolved features that are defined in the given <code>context type</code> and its supertypes. * Considers private methods of super types, too. * @return the resolved features. */ public ResolvedFeatures getResolvedFeatures(LightweightTypeReference contextType) { return new ResolvedFeatures(contextType, overrideTester); }
public List<IResolvedOperation> getDeclaredOperations(String erasedSignature) { if (declaredOperationsPerErasure != null) { return declaredOperationsPerErasure.get(erasedSignature); } return (declaredOperationsPerErasure = computeIndex(getDeclaredOperations())).get(erasedSignature); }
public List<IResolvedOperation> getAllOperations(String erasedSignature) { if (allOperationsPerErasure != null) { return allOperationsPerErasure.get(erasedSignature); } return (allOperationsPerErasure = computeIndex(getAllOperations())).get(erasedSignature); }
operationsMissingImplementation = Lists.newArrayList(); IVisibilityHelper visibilityHelper = new ContextualVisibilityHelper(this.visibilityHelper, resolvedFeatures.getType()); boolean flaggedType = false; for (IResolvedOperation operation : resolvedFeatures.getAllOperations()) { JvmDeclaredType operationDeclaringType = operation.getDeclaration().getDeclaringType(); if (operationDeclaringType != inferredType) { String erasureSignature = operation.getResolvedErasureSignature(); List<IResolvedOperation> declaredOperationsWithSameErasure = resolvedFeatures.getDeclaredOperations(erasureSignature); for (IResolvedOperation localOperation: declaredOperationsWithSameErasure) { if (!localOperation.isOverridingOrImplementing(operation.getDeclaration()).isOverridingOrImplementing()) {
protected List<IResolvedOperation> computeAllOperations() { JvmType rawType = getRawType(); if (!(rawType instanceof JvmDeclaredType)) { return Collections.emptyList(); } Multimap<String, AbstractResolvedOperation> processedOperations = LinkedHashMultimap.create(); for (IResolvedOperation resolvedOperation : getDeclaredOperations()) { processedOperations.put(resolvedOperation.getDeclaration().getSimpleName(), (AbstractResolvedOperation) resolvedOperation); } if (targetVersion.isAtLeast(JavaVersion.JAVA8)) { computeAllOperationsFromSortedSuperTypes((JvmDeclaredType) rawType, processedOperations); } else { Set<JvmType> processedTypes = Sets.newHashSet(rawType); computeAllOperationsFromSuperTypes((JvmDeclaredType) rawType, processedOperations, processedTypes); } // make sure the declared operations are the first in the list List<IResolvedOperation> result = new ArrayList<IResolvedOperation>(processedOperations.size()); result.addAll(getDeclaredOperations()); for (AbstractResolvedOperation operation : processedOperations.values()) { if (operation.getDeclaration().getDeclaringType() != rawType) { result.add(operation); } } return Collections.unmodifiableList(result); }
protected void doCheckDuplicateExecutables(JvmGenericType inferredType, final ResolvedFeatures resolvedFeatures, Set<EObject> flaggedOperations) { List<IResolvedOperation> declaredOperations = resolvedFeatures.getDeclaredOperations(); doCheckDuplicateExecutables(inferredType, declaredOperations, new Function<String, List<IResolvedOperation>>() { @Override public List<IResolvedOperation> apply(String erasedSignature) { return resolvedFeatures.getDeclaredOperations(erasedSignature); } }, flaggedOperations); final List<IResolvedConstructor> declaredConstructors = resolvedFeatures.getDeclaredConstructors(); doCheckDuplicateExecutables(inferredType, declaredConstructors, new Function<String, List<IResolvedConstructor>>() { @Override public List<IResolvedConstructor> apply(String erasedSignature) { if (declaredConstructors.size() == 1) { if (erasedSignature.equals(declaredConstructors.get(0).getResolvedErasureSignature())) { return declaredConstructors; } return Collections.emptyList(); } List<IResolvedConstructor> result = Lists.newArrayListWithCapacity(declaredConstructors.size()); for(IResolvedConstructor constructor: declaredConstructors) { if (erasedSignature.equals(constructor.getResolvedErasureSignature())) { result.add(constructor); } } return result; } }, flaggedOperations); }
protected List<IResolvedConstructor> computeDeclaredConstructors() { JvmType rawType = getRawType(); if (!(rawType instanceof JvmGenericType)) { return Collections.emptyList(); } List<IResolvedConstructor> result = Lists.newArrayList(); for(JvmConstructor constructor: ((JvmGenericType)rawType).getDeclaredConstructors()) { result.add(new ResolvedConstructor(constructor, getType())); } return Collections.unmodifiableList(result); }
protected void addConstructorCandidates(final ResolvedFeatures resolvedFeatures, final IVisibilityHelper visibilityHelper, final List<IResolvedExecutable> result) { LightweightTypeReference typeReference = resolvedFeatures.getType(); List<LightweightTypeReference> superTypes = typeReference.getSuperTypes(); for (final LightweightTypeReference superType : superTypes) { boolean _not = (!_isInterfaceType); if (_not) { List<IResolvedConstructor> declaredConstructors = resolvedFeatures.getDeclaredConstructors(); Set<String> erasedSignatures = Sets.<String>newHashSet(); for (final IResolvedConstructor constructor : declaredConstructors) { List<IResolvedConstructor> constructors = superClass.getDeclaredConstructors(); for (final IResolvedConstructor constructor_1 : constructors) {
public List<IResolvedExecutable> getImplementationCandidates(final JvmDeclaredType type, final boolean isAnonymous) { if (((type == null) || (!(type instanceof JvmGenericType)))) { return Collections.<IResolvedExecutable>emptyList(); } JavaVersion sourceVersion = this.generatorConfigProvider.get(type).getJavaSourceVersion(); ResolvedFeatures resolvedFeatures = this.overrideHelper.getResolvedFeatures(type, sourceVersion); List<IResolvedExecutable> result = Lists.<IResolvedExecutable>newArrayList(); LightweightTypeReference _type = resolvedFeatures.getType(); ContextualVisibilityHelper contextualVisibilityHelper = new ContextualVisibilityHelper(this.visibilityHelper, _type); this.addOperationCandidates(resolvedFeatures, contextualVisibilityHelper, result); if (((!isAnonymous) && (!((JvmGenericType) type).isInterface()))) { this.addConstructorCandidates(resolvedFeatures, contextualVisibilityHelper, result); } return result; }
@Override public Iterable<? extends ResolvedMethod> getAllResolvedMethods() { final Function1<IResolvedOperation, ResolvedMethod> _function = (IResolvedOperation it) -> { return this.getCompilationUnit().toResolvedMethod(it); }; return ListExtensions.<IResolvedOperation, ResolvedMethod>map(this.getCompilationUnit().getOverrideHelper().getResolvedFeatures(this.getDelegate()).getAllOperations(), _function); }
protected void computeAllOperationsFromSuperTypes(JvmDeclaredType type, Multimap<String, AbstractResolvedOperation> processedOperations, Set<JvmType> processedTypes) { for (JvmTypeReference superType: type.getSuperTypes()) { JvmType rawSuperType = superType.getType(); if (rawSuperType instanceof JvmDeclaredType && !rawSuperType.eIsProxy() && processedTypes.add(rawSuperType)) { computeAllOperations((JvmDeclaredType) rawSuperType, processedOperations); computeAllOperationsFromSuperTypes((JvmDeclaredType) rawSuperType, processedOperations, processedTypes); } } }
@Override public Iterable<? extends ResolvedConstructor> getDeclaredResolvedConstructors() { final Function1<IResolvedConstructor, ResolvedConstructor> _function = (IResolvedConstructor it) -> { return this.getCompilationUnit().toResolvedConstructor(it); }; return ListExtensions.<IResolvedConstructor, ResolvedConstructor>map(this.getCompilationUnit().getOverrideHelper().getResolvedFeatures(this.getDelegate()).getDeclaredConstructors(), _function); }
public List<IResolvedOperation> getAllOperations() { if (allOperations != null) { return allOperations; } return allOperations = computeAllOperations(); }
public List<IResolvedConstructor> getDeclaredConstructors() { if (declaredConstructors != null) { return declaredConstructors; } return declaredConstructors = computeDeclaredConstructors(); }
protected List<IResolvedField> computeDeclaredFields() { JvmType rawType = getRawType(); if (!(rawType instanceof JvmGenericType)) { return Collections.emptyList(); } List<IResolvedField> result = Lists.newArrayList(); for(JvmField field: ((JvmGenericType)rawType).getDeclaredFields()) { result.add(new ResolvedField(field, getType())); } return Collections.unmodifiableList(result); }
for(JvmType superClass: superTypes.getSuperTypesNoInterfaces()) { if (superClass instanceof JvmDeclaredType) { computeAllOperations((JvmDeclaredType) superClass, processedOperations);
protected void doCheckFunctionOverrides(ResolvedFeatures resolvedFeatures, Set<EObject> flaggedOperations) { for(IResolvedOperation operation: resolvedFeatures.getDeclaredOperations()) { doCheckFunctionOverrides(operation, flaggedOperations); } }
/** * Returns the resolved features targeting a specific Java version in order to support new language features. */ public ResolvedFeatures getResolvedFeatures(LightweightTypeReference contextType, JavaVersion targetVersion) { return new ResolvedFeatures(contextType, overrideTester, targetVersion); }