org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope Java Examples

@Override
public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope scope) {
    Annotation[] annotations = typeDeclaration.annotations;
    if (hasRelevantAnnotations(annotations)) {
        SourceTypeBinding binding = typeDeclaration.binding;
        if (binding == null) {
            return true;
        }
        String fqn = new String(typeDeclaration.binding.readableName());
        Item item = ClassItem.create(fqn, ClassKind.forType(typeDeclaration));
        addItem(fqn, item);
        addAnnotations(annotations, item);

    }
    return true;
}
 

public int recordFunctionalType(Scope scope) {
	while (scope != null) {
		switch (scope.kind) {
			case Scope.METHOD_SCOPE :
				ReferenceContext context = ((MethodScope) scope).referenceContext;
				if (context instanceof LambdaExpression) {
					LambdaExpression expression = (LambdaExpression) context;
					if (expression != expression.original) // fake universe.
						return 0;
				}
				break; 
			case Scope.COMPILATION_UNIT_SCOPE :
				CompilationUnitDeclaration unit = ((CompilationUnitScope) scope).referenceContext;
				return unit.record(this);
		}
		scope = scope.parent;
	}
	return 0; // not reached.
}
 

public IPackageBinding getPackage() {
	if (this.binding != null) {
		switch (this.binding.kind()) {
			case Binding.BASE_TYPE :
			case Binding.ARRAY_TYPE :
			case Binding.TYPE_PARAMETER : // includes capture scenario
			case Binding.WILDCARD_TYPE :
			case Binding.INTERSECTION_TYPE:
				return null;
		}
		IPackageBinding packageBinding = this.resolver.getPackageBinding(this.binding.getPackage());
		if (packageBinding != null) return packageBinding;
	}
	if (this.innerTypeBinding != null && this.dimensions > 0) {
		return null;
	}
	CompilationUnitScope scope = this.resolver.scope();
	if (scope != null) {
		return this.resolver.getPackageBinding(scope.getCurrentPackage());
	}
	return null;
}
 

private static List<MethodBinding> getApplicableExtensionMethodsDefinedInProvider(EclipseNode typeNode, ReferenceBinding extensionMethodProviderBinding,
		TypeBinding receiverType) {
	
	List<MethodBinding> extensionMethods = new ArrayList<MethodBinding>();
	CompilationUnitScope cuScope = ((CompilationUnitDeclaration) typeNode.top().get()).scope;
	for (MethodBinding method : extensionMethodProviderBinding.methods()) {
		if (!method.isStatic()) continue;
		if (!method.isPublic()) continue;
		if (method.parameters == null || method.parameters.length == 0) continue;
		TypeBinding firstArgType = method.parameters[0];
		if (receiverType.isProvablyDistinct(firstArgType) && !receiverType.isCompatibleWith(firstArgType.erasure())) continue;
		TypeBinding[] argumentTypes = Arrays.copyOfRange(method.parameters, 1, method.parameters.length);
		if ((receiverType instanceof ReferenceBinding) && ((ReferenceBinding) receiverType).getExactMethod(method.selector, argumentTypes, cuScope) != null) continue;
		extensionMethods.add(method);
	}
	return extensionMethods;
}
 

@Override
public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope scope) {
	SourceTypeBinding binding = typeDeclaration.binding;
	if (binding == null) {
		return false;
	}
	Annotation[] annotations = typeDeclaration.annotations;
	if (annotations != null) {
		this.resolveAnnotations(
				typeDeclaration.staticInitializerScope,
				annotations,
				binding);
	}
	return true;
}
 

public boolean visit(
	TypeDeclaration typeDeclaration,
	CompilationUnitScope scope) {
		if (typeDeclaration.declarationSourceStart <= this.position
			&& this.position <= typeDeclaration.declarationSourceEnd) {
				this.enclosingType = typeDeclaration;
				return true;
		}
		return false;
}
 

/**
 * Constructor for DefaultBindingResolver.
 */
DefaultBindingResolver(CompilationUnitScope scope, WorkingCopyOwner workingCopyOwner, BindingTables bindingTables, boolean isRecoveringBindings, boolean fromJavaProject) {
	this.newAstToOldAst = new HashMap();
	this.astNodesToBlockScope = new HashMap();
	this.bindingsToAstNodes = new HashMap();
	this.bindingTables = bindingTables;
	this.scope = scope;
	this.workingCopyOwner = workingCopyOwner;
	this.isRecoveringBindings = isRecoveringBindings;
	this.fromJavaProject = fromJavaProject;
}
 

DefaultBindingResolver(LookupEnvironment lookupEnvironment, WorkingCopyOwner workingCopyOwner, BindingTables bindingTables, boolean isRecoveringBindings, boolean fromJavaProject) {
	this.newAstToOldAst = new HashMap();
	this.astNodesToBlockScope = new HashMap();
	this.bindingsToAstNodes = new HashMap();
	this.bindingTables = bindingTables;
	this.scope = new CompilationUnitScope(new CompilationUnitDeclaration(null, null, -1), lookupEnvironment);
	this.workingCopyOwner = workingCopyOwner;
	this.isRecoveringBindings = isRecoveringBindings;
	this.fromJavaProject = fromJavaProject;
}
 

public CompilationUnitScope scope() {
	return this.scope;
}
 

@Override
public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope scope) {
    return recordTypedefs(typeDeclaration);
}
 

public void traverse(ASTVisitor visitor, CompilationUnitScope unitScope, boolean skipOnError) {
	if (skipOnError && this.ignoreFurtherInvestigation)
		return;
	try {
		if (visitor.visit(this, this.scope)) {
			if (this.types != null && isPackageInfo()) {
	            // resolve synthetic type declaration
				final TypeDeclaration syntheticTypeDeclaration = this.types[0];
				// resolve javadoc package if any
				final MethodScope methodScope = syntheticTypeDeclaration.staticInitializerScope;
				// Don't traverse in null scope and invite trouble a la bug 252555.
				if (this.javadoc != null && methodScope != null) {
					this.javadoc.traverse(visitor, methodScope);
				}
				// Don't traverse in null scope and invite trouble a la bug 252555.
				if (this.currentPackage != null && methodScope != null) {
					final Annotation[] annotations = this.currentPackage.annotations;
					if (annotations != null) {
						int annotationsLength = annotations.length;
						for (int i = 0; i < annotationsLength; i++) {
							annotations[i].traverse(visitor, methodScope);
						}
					}
				}
			}
			if (this.currentPackage != null) {
				this.currentPackage.traverse(visitor, this.scope);
			}
			if (this.imports != null) {
				int importLength = this.imports.length;
				for (int i = 0; i < importLength; i++) {
					this.imports[i].traverse(visitor, this.scope);
				}
			}
			if (this.types != null) {
				int typesLength = this.types.length;
				for (int i = 0; i < typesLength; i++) {
					this.types[i].traverse(visitor, this.scope);
				}
			}
		}
		visitor.endVisit(this, this.scope);
	} catch (AbortCompilationUnit e) {
		// ignore
	}
}
 

public void traverse(ASTVisitor visitor, CompilationUnitScope unitScope) {
	traverse(visitor, unitScope, true);
}
 

public boolean visit(
	TypeDeclaration typeDeclaration,
	CompilationUnitScope scope) {
	return true; // do nothing by default, keep traversing
}
 

public boolean visit(ImportReference importRef, CompilationUnitScope scope) {
	return true; // do nothing by default, keep traversing
}
 

public boolean visit(
	CompilationUnitDeclaration compilationUnitDeclaration,
	CompilationUnitScope scope) {
	return true; // do nothing by default, keep traversing
}
 

public void endVisit(
	TypeDeclaration typeDeclaration,
	CompilationUnitScope scope) {
	// do nothing by default
}
 

public void endVisit(ImportReference importRef, CompilationUnitScope scope) {
	// do nothing by default
}
 

public void endVisit(
	CompilationUnitDeclaration compilationUnitDeclaration,
	CompilationUnitScope scope) {
	// do nothing by default
}
 

@Override public boolean visit(CompilationUnitDeclaration node, CompilationUnitScope scope) {
	fixPositions(setGeneratedBy(node, source));
	return super.visit(node, scope);
}
 

public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope scope) {
	return visitType(typeDeclaration);
}
 

@Override public boolean visit(TypeDeclaration node, CompilationUnitScope scope) {
	fixPositions(setGeneratedBy(node, source));
	return super.visit(node, scope);
}
 

@Override public boolean visit(ImportReference node, CompilationUnitScope scope) {
	fixPositions(setGeneratedBy(node, source));
	return super.visit(node, scope);
}
 

/**
 * Returns the compilation unit scope used by this binding resolver.
 * Returns <code>null</code> if none.
 *
 * @return the compilation unit scope by this resolver, or <code>null</code> if none.
 */
public CompilationUnitScope scope() {
	return null;
}