/*******************************************************************************
* Copyright (c) 2000, 2009 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;
public class NestedTypeBinding extends SourceTypeBinding {
public SourceTypeBinding enclosingType;
public SyntheticArgumentBinding[] enclosingInstances;
private ReferenceBinding[] enclosingTypes= Binding.UNINITIALIZED_REFERENCE_TYPES;
public SyntheticArgumentBinding[] outerLocalVariables;
private int outerLocalVariablesSlotSize= -1; // amount of slots used by synthetic outer local variables
public NestedTypeBinding(char[][] typeName, ClassScope scope, SourceTypeBinding enclosingType) {
super(typeName, enclosingType.fPackage, scope);
this.tagBits|= (TagBits.IsNestedType | TagBits.ContainsNestedTypeReferences);
this.enclosingType= enclosingType;
}
/* Add a new synthetic argument for <actualOuterLocalVariable>.
* Answer the new argument or the existing argument if one already existed.
*/
public SyntheticArgumentBinding addSyntheticArgument(LocalVariableBinding actualOuterLocalVariable) {
SyntheticArgumentBinding synthLocal= null;
if (this.outerLocalVariables == null) {
synthLocal= new SyntheticArgumentBinding(actualOuterLocalVariable);
this.outerLocalVariables= new SyntheticArgumentBinding[] { synthLocal };
} else {
int size= this.outerLocalVariables.length;
int newArgIndex= size;
for (int i= size; --i >= 0;) { // must search backwards
if (this.outerLocalVariables[i].actualOuterLocalVariable == actualOuterLocalVariable)
return this.outerLocalVariables[i]; // already exists
if (this.outerLocalVariables[i].id > actualOuterLocalVariable.id)
newArgIndex= i;
}
SyntheticArgumentBinding[] synthLocals= new SyntheticArgumentBinding[size + 1];
System.arraycopy(this.outerLocalVariables, 0, synthLocals, 0, newArgIndex);
synthLocals[newArgIndex]= synthLocal= new SyntheticArgumentBinding(actualOuterLocalVariable);
System.arraycopy(this.outerLocalVariables, newArgIndex, synthLocals, newArgIndex + 1, size - newArgIndex);
this.outerLocalVariables= synthLocals;
}
//System.out.println("Adding synth arg for local var: " + new String(actualOuterLocalVariable.name) + " to: " + new String(this.readableName()));
if (this.scope.referenceCompilationUnit().isPropagatingInnerClassEmulation)
updateInnerEmulationDependents();
return synthLocal;
}
/* Add a new synthetic argument for <enclosingType>.
* Answer the new argument or the existing argument if one already existed.
*/
public SyntheticArgumentBinding addSyntheticArgument(ReferenceBinding targetEnclosingType) {
SyntheticArgumentBinding synthLocal= null;
if (this.enclosingInstances == null) {
synthLocal= new SyntheticArgumentBinding(targetEnclosingType);
this.enclosingInstances= new SyntheticArgumentBinding[] { synthLocal };
} else {
int size= this.enclosingInstances.length;
int newArgIndex= size;
for (int i= size; --i >= 0;) {
if (this.enclosingInstances[i].type == targetEnclosingType)
return this.enclosingInstances[i]; // already exists
if (enclosingType() == targetEnclosingType)
newArgIndex= 0;
}
SyntheticArgumentBinding[] newInstances= new SyntheticArgumentBinding[size + 1];
System.arraycopy(this.enclosingInstances, 0, newInstances, newArgIndex == 0 ? 1 : 0, size);
newInstances[newArgIndex]= synthLocal= new SyntheticArgumentBinding(targetEnclosingType);
this.enclosingInstances= newInstances;
}
//System.out.println("Adding synth arg for enclosing type: " + new String(enclosingType.readableName()) + " to: " + new String(this.readableName()));
if (this.scope.referenceCompilationUnit().isPropagatingInnerClassEmulation)
updateInnerEmulationDependents();
return synthLocal;
}
/* Add a new synthetic argument and field for <actualOuterLocalVariable>.
* Answer the new argument or the existing argument if one already existed.
*/
public SyntheticArgumentBinding addSyntheticArgumentAndField(LocalVariableBinding actualOuterLocalVariable) {
SyntheticArgumentBinding synthLocal= addSyntheticArgument(actualOuterLocalVariable);
if (synthLocal == null)
return null;
if (synthLocal.matchingField == null)
synthLocal.matchingField= addSyntheticFieldForInnerclass(actualOuterLocalVariable);
return synthLocal;
}
/* Add a new synthetic argument and field for <enclosingType>.
* Answer the new argument or the existing argument if one already existed.
*/
public SyntheticArgumentBinding addSyntheticArgumentAndField(ReferenceBinding targetEnclosingType) {
SyntheticArgumentBinding synthLocal= addSyntheticArgument(targetEnclosingType);
if (synthLocal == null)
return null;
if (synthLocal.matchingField == null)
synthLocal.matchingField= addSyntheticFieldForInnerclass(targetEnclosingType);
return synthLocal;
}
/* Answer the receiver's enclosing type... null if the receiver is a top level type.
*/
public ReferenceBinding enclosingType() {
return this.enclosingType;
}
/**
* @return the enclosingInstancesSlotSize
*/
public int getEnclosingInstancesSlotSize() {
return this.enclosingInstances == null ? 0 : this.enclosingInstances.length;
}
/**
* @return the outerLocalVariablesSlotSize
*/
public int getOuterLocalVariablesSlotSize() {
if (this.outerLocalVariablesSlotSize < 0) {
this.outerLocalVariablesSlotSize= 0;
int outerLocalsCount= this.outerLocalVariables == null ? 0 : this.outerLocalVariables.length;
for (int i= 0; i < outerLocalsCount; i++) {
SyntheticArgumentBinding argument= this.outerLocalVariables[i];
switch (argument.type.id) {
case TypeIds.T_long:
case TypeIds.T_double:
this.outerLocalVariablesSlotSize+= 2;
break;
default:
this.outerLocalVariablesSlotSize++;
break;
}
}
}
return this.outerLocalVariablesSlotSize;
}
/* Answer the synthetic argument for <actualOuterLocalVariable> or null if one does not exist.
*/
public SyntheticArgumentBinding getSyntheticArgument(LocalVariableBinding actualOuterLocalVariable) {
if (this.outerLocalVariables == null)
return null; // is null if no outer local variables are known
for (int i= this.outerLocalVariables.length; --i >= 0;)
if (this.outerLocalVariables[i].actualOuterLocalVariable == actualOuterLocalVariable)
return this.outerLocalVariables[i];
return null;
}
/* Answer the synthetic argument for <targetEnclosingType> or null if one does not exist.
*/
public SyntheticArgumentBinding getSyntheticArgument(ReferenceBinding targetEnclosingType, boolean onlyExactMatch) {
if (this.enclosingInstances == null)
return null; // is null if no enclosing instances are known
// exact match
for (int i= this.enclosingInstances.length; --i >= 0;)
if (this.enclosingInstances[i].type == targetEnclosingType)
if (this.enclosingInstances[i].actualOuterLocalVariable == null)
return this.enclosingInstances[i];
// type compatibility : to handle cases such as
// class T { class M{}}
// class S extends T { class N extends M {}} --> need to use S as a default enclosing instance for the super constructor call in N().
if (!onlyExactMatch) {
for (int i= this.enclosingInstances.length; --i >= 0;)
if (this.enclosingInstances[i].actualOuterLocalVariable == null)
if (this.enclosingInstances[i].type.findSuperTypeOriginatingFrom(targetEnclosingType) != null)
return this.enclosingInstances[i];
}
return null;
}
public SyntheticArgumentBinding[] syntheticEnclosingInstances() {
return this.enclosingInstances; // is null if no enclosing instances are required
}
public ReferenceBinding[] syntheticEnclosingInstanceTypes() {
if (this.enclosingTypes == UNINITIALIZED_REFERENCE_TYPES) {
if (this.enclosingInstances == null) {
this.enclosingTypes= null;
} else {
int length= this.enclosingInstances.length;
this.enclosingTypes= new ReferenceBinding[length];
for (int i= 0; i < length; i++) {
this.enclosingTypes[i]= (ReferenceBinding)this.enclosingInstances[i].type;
}
}
}
return this.enclosingTypes;
}
public SyntheticArgumentBinding[] syntheticOuterLocalVariables() {
return this.outerLocalVariables; // is null if no outer locals are required
}
/*
* Trigger the dependency mechanism forcing the innerclass emulation
* to be propagated to all dependent source types.
*/
public void updateInnerEmulationDependents() {
// nothing to do in general, only local types are doing anything
}
}