Java LocalTypeBinding类代码示例

import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding; //导入依赖的package包/类
public void acceptLocalType(TypeBinding typeBinding) {
	IJavaElement res =  null;
	if(typeBinding instanceof ParameterizedTypeBinding) {
		LocalTypeBinding localTypeBinding = (LocalTypeBinding)((ParameterizedTypeBinding)typeBinding).genericType();
		res = findLocalElement(localTypeBinding.sourceStart());
	} else if(typeBinding instanceof SourceTypeBinding) {
		res = findLocalElement(((SourceTypeBinding)typeBinding).sourceStart());
	}
	if(res != null && res.getElementType() == IJavaElement.TYPE) {
		res = ((JavaElement)res).resolved(typeBinding);
		addElement(res);
		if(SelectionEngine.DEBUG){
			System.out.print("SELECTION - accept type("); //$NON-NLS-1$
			System.out.print(res.toString());
			System.out.println(")"); //$NON-NLS-1$
		}
	}
}
 

import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding; //导入依赖的package包/类
public void acceptLocalTypeParameter(TypeVariableBinding typeVariableBinding) {
	IJavaElement res;
	if(typeVariableBinding.declaringElement instanceof ParameterizedTypeBinding) {
		LocalTypeBinding localTypeBinding = (LocalTypeBinding)((ParameterizedTypeBinding)typeVariableBinding.declaringElement).genericType();
		res = findLocalElement(localTypeBinding.sourceStart());
	} else {
		SourceTypeBinding typeBinding = (SourceTypeBinding)typeVariableBinding.declaringElement;
		res = findLocalElement(typeBinding.sourceStart());
	}
	if (res != null && res.getElementType() == IJavaElement.TYPE) {
		IType type = (IType) res;
		ITypeParameter typeParameter = type.getTypeParameter(new String(typeVariableBinding.sourceName));
		if (typeParameter.exists()) {
			addElement(typeParameter);
			if(SelectionEngine.DEBUG){
				System.out.print("SELECTION - accept type parameter("); //$NON-NLS-1$
				System.out.print(typeParameter.toString());
				System.out.println(")"); //$NON-NLS-1$
			}
		}
	}
}
 

import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding; //导入依赖的package包/类
void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {
	ReferenceBinding superTypeErasure = (ReferenceBinding) this.binding.declaringClass.erasure();

	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) == 0)	{
	// perform some emulation work in case there is some and we are inside a local type only
	if (superTypeErasure.isNestedType()
		&& currentScope.enclosingSourceType().isLocalType()) {

		if (superTypeErasure.isLocalType()) {
			((LocalTypeBinding) superTypeErasure).addInnerEmulationDependent(currentScope, this.qualification != null);
		} else {
			// locally propagate, since we already now the desired shape for sure
			currentScope.propagateInnerEmulation(superTypeErasure, this.qualification != null);
		}
	}
	}
}
 

import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding; //导入依赖的package包/类
public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {
	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) == 0)	{
	ReferenceBinding allocatedTypeErasure = (ReferenceBinding) this.binding.declaringClass.erasure();

	// perform some extra emulation work in case there is some and we are inside a local type only
	if (allocatedTypeErasure.isNestedType()
		&& currentScope.enclosingSourceType().isLocalType()) {

		if (allocatedTypeErasure.isLocalType()) {
			((LocalTypeBinding) allocatedTypeErasure).addInnerEmulationDependent(currentScope, this.enclosingInstance != null);
		} else {
			// locally propagate, since we already now the desired shape for sure
			currentScope.propagateInnerEmulation(allocatedTypeErasure, this.enclosingInstance != null);
		}
	}
	}
}
 

import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding; //导入依赖的package包/类
public void consumeLocalType(char[] uniqueKey) {
		LocalTypeBinding[] localTypeBindings  = this.parsedUnit.localTypes;
		for (int i = 0; i < this.parsedUnit.localTypeCount; i++)
			if (CharOperation.equals(uniqueKey, localTypeBindings[i].computeUniqueKey(false/*not a leaf*/))) {
				this.typeBinding = localTypeBindings[i];
				return;
			}
}
 

import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding; //导入依赖的package包/类
private int generateEnclosingMethodAttribute() {
	int localContentsOffset = this.contentsOffset;
	// add enclosing method attribute (1.5 mode only)
	if (localContentsOffset + 10 >= this.contents.length) {
		resizeContents(10);
	}
	int enclosingMethodAttributeNameIndex =
		this.constantPool.literalIndex(AttributeNamesConstants.EnclosingMethodName);
	this.contents[localContentsOffset++] = (byte) (enclosingMethodAttributeNameIndex >> 8);
	this.contents[localContentsOffset++] = (byte) enclosingMethodAttributeNameIndex;
	// the length of a signature attribute is equals to 2
	this.contents[localContentsOffset++] = 0;
	this.contents[localContentsOffset++] = 0;
	this.contents[localContentsOffset++] = 0;
	this.contents[localContentsOffset++] = 4;

	int enclosingTypeIndex = this.constantPool.literalIndexForType(this.referenceBinding.enclosingType().constantPoolName());
	this.contents[localContentsOffset++] = (byte) (enclosingTypeIndex >> 8);
	this.contents[localContentsOffset++] = (byte) enclosingTypeIndex;
	byte methodIndexByte1 = 0;
	byte methodIndexByte2 = 0;
	if (this.referenceBinding instanceof LocalTypeBinding) {
		MethodBinding methodBinding = ((LocalTypeBinding) this.referenceBinding).enclosingMethod;
		if (methodBinding != null) {
			int enclosingMethodIndex = this.constantPool.literalIndexForNameAndType(methodBinding.selector, methodBinding.signature(this));
			methodIndexByte1 = (byte) (enclosingMethodIndex >> 8);
			methodIndexByte2 = (byte) enclosingMethodIndex;
		}
	}
	this.contents[localContentsOffset++] = methodIndexByte1;
	this.contents[localContentsOffset++] = methodIndexByte2;
	this.contentsOffset = localContentsOffset;
	return 1;
}
 

import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding; //导入依赖的package包/类
public void cleanUp() {
	if (this.types != null) {
		for (int i = 0, max = this.types.length; i < max; i++) {
			cleanUp(this.types[i]);
		}
		for (int i = 0, max = this.localTypeCount; i < max; i++) {
		    LocalTypeBinding localType = this.localTypes[i];
			// null out the type's scope backpointers
			localType.scope = null; // local members are already in the list
			localType.enclosingCase = null;
		}
	}

	this.compilationResult.recoveryScannerData = null; // recovery is already done

	ClassFile[] classFiles = this.compilationResult.getClassFiles();
	for (int i = 0, max = classFiles.length; i < max; i++) {
		// clear the classFile back pointer to the bindings
		ClassFile classFile = classFiles[i];
		// null out the classfile backpointer to a type binding
		classFile.referenceBinding = null;
		classFile.innerClassesBindings = null;
		classFile.bootstrapMethods = null;
		classFile.missingTypes = null;
		classFile.visitedTypes = null;
	}

	this.suppressWarningAnnotations = null;
}
 

import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding; //导入依赖的package包/类
public void propagateInnerEmulationForAllLocalTypes() {
	this.isPropagatingInnerClassEmulation = true;
	for (int i = 0, max = this.localTypeCount; i < max; i++) {
		LocalTypeBinding localType = this.localTypes[i];
		// only propagate for reachable local types
		if ((localType.scope.referenceType().bits & IsReachable) != 0) {
			localType.updateInnerEmulationDependents();
		}
	}
}
 

import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding; //导入依赖的package包/类
public void record(LocalTypeBinding localType) {
	if (this.localTypeCount == 0) {
		this.localTypes = new LocalTypeBinding[5];
	} else if (this.localTypeCount == this.localTypes.length) {
		System.arraycopy(this.localTypes, 0, (this.localTypes = new LocalTypeBinding[this.localTypeCount * 2]), 0, this.localTypeCount);
	}
	this.localTypes[this.localTypeCount++] = localType;
}
 

import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding; //导入依赖的package包/类
public void cleanUp() {
	if (this.types != null) {
		for (int i = 0, max = this.types.length; i < max; i++) {
			cleanUp(this.types[i]);
		}
		for (int i = 0, max = this.localTypeCount; i < max; i++) {
		    LocalTypeBinding localType = this.localTypes[i];
			// null out the type's scope backpointers
			localType.scope = null; // local members are already in the list
			localType.enclosingCase = null;
		}
	}

	this.compilationResult.recoveryScannerData = null; // recovery is already done

	ClassFile[] classFiles = this.compilationResult.getClassFiles();
	for (int i = 0, max = classFiles.length; i < max; i++) {
		// clear the classFile back pointer to the bindings
		ClassFile classFile = classFiles[i];
		// null out the classfile backpointer to a type binding
		classFile.referenceBinding = null;
		classFile.innerClassesBindings = null;
		classFile.missingTypes = null;
		classFile.visitedTypes = null;
	}

	this.suppressWarningAnnotations = null;
}
 

import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding; //导入依赖的package包/类
public TypeBinding resolveType(BlockScope scope) {
	super.resolveType(scope);

	if (this.binding == null) {
		throw new SelectionNodeFound();
	}

	// tolerate some error cases
	if (!this.binding.isValidBinding()) {
		switch (this.binding.problemId()) {
			case ProblemReasons.NotVisible:
				// visibility is ignored
				break;
			case ProblemReasons.NotFound:
				if (this.resolvedType != null && this.resolvedType.isValidBinding()) {
					throw new SelectionNodeFound(this.resolvedType);
				}
				throw new SelectionNodeFound();
			default:
				throw new SelectionNodeFound();
		}
	}

	if (this.anonymousType == null)
		throw new SelectionNodeFound(this.binding);

	// if selecting a type for an anonymous type creation, we have to
	// find its target super constructor (if extending a class) or its target
	// super interface (if extending an interface)
	if (this.anonymousType.binding != null) {
		LocalTypeBinding localType = (LocalTypeBinding) this.anonymousType.binding;
		if (localType.superInterfaces == Binding.NO_SUPERINTERFACES) {
			// find the constructor binding inside the super constructor call
			ConstructorDeclaration constructor = (ConstructorDeclaration) this.anonymousType.declarationOf(this.binding.original());
			if (constructor != null) {
				throw new SelectionNodeFound(constructor.constructorCall.binding);
			}
			throw new SelectionNodeFound(this.binding);
		}
		// open on the only super interface
		throw new SelectionNodeFound(localType.superInterfaces[0]);
	} else {
		if (this.resolvedType.isInterface()) {
			throw new SelectionNodeFound(this.resolvedType);
		}
		throw new SelectionNodeFound(this.binding);
	}
}
 

import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding; //导入依赖的package包/类
private void createTypes(TypeDeclaration x) {
  SourceInfo info = makeSourceInfo(x);
  try {
    SourceTypeBinding binding = x.binding;
    String name;
    if (binding instanceof LocalTypeBinding) {
      char[] localName = binding.constantPoolName();
      name = new String(localName).replace('/', '.');
    } else {
      name = dotify(binding.compoundName);
    }
    name = intern(name);
    JDeclaredType type;
    if (binding.isClass()) {
      type = new JClassType(info, name, binding.isAbstract(), binding.isFinal());
    } else if (binding.isInterface() || binding.isAnnotationType()) {
      type = new JInterfaceType(info, name);
    } else if (binding.isEnum()) {
      if (binding.isAnonymousType()) {
        // Don't model an enum subclass as a JEnumType.
        type = new JClassType(info, name, false, true);
      } else {
        type = new JEnumType(info, name, binding.isAbstract());
      }
    } else {
      throw new InternalCompilerException("ReferenceBinding is not a class, interface, or enum.");
    }
    typeMap.setSourceType(binding, type);
    newTypes.add(type);
    if (x.memberTypes != null) {
      for (TypeDeclaration memberType : x.memberTypes) {
        createTypes(memberType);
      }
    }
  } catch (Throwable e) {
    InternalCompilerException ice = translateException(null, e);
    StringBuffer sb = new StringBuffer();
    x.printHeader(0, sb);
    ice.addNode(x.getClass().getName(), sb.toString(), info);
    throw ice;
  }
}