/**********************************************************************
 * This file is part of "Object Teams Development Tooling"-Software
 *
 * Copyright 2004, 2019 Fraunhofer Gesellschaft, Munich, Germany,
 * for its Fraunhofer Institute for Computer Architecture and Software
 * Technology (FIRST), Berlin, Germany and Technical University Berlin,
 * Germany.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 * $Id: RoleModel.java 23416 2010-02-03 19:59:31Z stephan $
 *
 * Please visit http://www.eclipse.org/objectteams for updates and contact.
 *
 * Contributors:
 * Fraunhofer FIRST - Initial API and implementation
 * Technical University Berlin - Initial API and implementation
 **********************************************************************/
package org.eclipse.objectteams.otdt.internal.core.compiler.model;

import static org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants.AccInterface;
import static org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants.AccSynthetic;
import static org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers.AccOverridingRole;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;

import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ClassFile;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions.WeavingScheme;
import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
import org.eclipse.jdt.internal.compiler.lookup.BinaryTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope;
import org.eclipse.jdt.internal.compiler.lookup.ElementValuePair;
import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
import org.eclipse.jdt.internal.compiler.lookup.PackageBinding;
import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.Scope;
import org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.SyntheticMethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.TagBits;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
import org.eclipse.objectteams.otdt.core.compiler.IOTConstants;
import org.eclipse.objectteams.otdt.core.exceptions.InternalCompilerError;
import org.eclipse.objectteams.otdt.internal.core.compiler.ast.AbstractMethodMappingDeclaration;
import org.eclipse.objectteams.otdt.internal.core.compiler.ast.CallinMappingDeclaration;
import org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.AbstractAttribute;
import org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.CPTypeAnchorAttribute;
import org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.CallinMethodMappingsAttribute;
import org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.CalloutMappingsAttribute;
import org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.OTSpecialAccessAttribute;
import org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.OTSpecialAccessAttribute.CalloutToFieldDesc;
import org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.RoleLocalTypesAttribute;
import org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.SingleValueAttribute;
import org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.WordValueAttribute;
import org.eclipse.objectteams.otdt.internal.core.compiler.control.Config;
import org.eclipse.objectteams.otdt.internal.core.compiler.control.Dependencies;
import org.eclipse.objectteams.otdt.internal.core.compiler.control.ITranslationStates;
import org.eclipse.objectteams.otdt.internal.core.compiler.lifting.Lifting;
import org.eclipse.objectteams.otdt.internal.core.compiler.lifting.Lifting.InstantiationPolicy;
import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.CallinCalloutBinding;
import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.RoleTypeBinding;
import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.SyntheticRoleFieldAccess;
import org.eclipse.objectteams.otdt.internal.core.compiler.mappings.CalloutImplementor;
import org.eclipse.objectteams.otdt.internal.core.compiler.statemachine.copyinheritance.CopyInheritance;
import org.eclipse.objectteams.otdt.internal.core.compiler.statemachine.copyinheritance.TypeLevel;
import org.eclipse.objectteams.otdt.internal.core.compiler.statemachine.transformer.RoleSplitter;
import org.eclipse.objectteams.otdt.internal.core.compiler.util.TypeAnalyzer;

/**
 * This class augments and generalizes ReferenceBinding and MemberTypeDeclaration
 * to take some additional information for role classes.
 *
 * These are the main tasks:
 * <ul>
 *   <li>Store byte code from tsuper role before adjustment
 *   <li>Link to team, link ifc/class parts, link to tsuper role
 *   <li>record the need to create a concrete _OT$getBase() method.
 *   <li>Iterate through role hierarchies.
 * </ul>
 *
 * @author stephan
 * @version $Id: RoleModel.java 23416 2010-02-03 19:59:31Z stephan $
 */
public class RoleModel extends TypeModel
{
	// Flag constants for tagBits:
	// is parameterized type instantiated via tsuper-link?
	public static final int IsViewedAsTSuper = ASTNode.Bit1;

    // had the baseclass field/playedBy problems?
    public static final int BaseclassHasProblems = ASTNode.Bit2;

    // several issues making lifting impossible
    public static final int HasLiftingProblem = ASTNode.Bit3;


	// ========== Byte code related fields: ======================
	// name to use for ClassFileReader when re-interpreting existing constant pool
    public static final char[] NO_SOURCE_FILE = "<intermediate>".toCharArray(); //$NON-NLS-1$

	/** Temporarily store the ClassFile to initialize offsets later. */
    private ClassFile _classFile = null;

    /** The full byte code of this class. */
    private byte[] _classByteCode = null;

    private int    _headerOffset = 0;

    /** Offsets into the constant pool */
    private int[]  _constantPoolOffsets = null;

    /** A table of all offsets to methods within the byte code */
    private HashMap <MethodBinding, Integer> _methodByteCodeOffsets = new HashMap<MethodBinding, Integer>();

    // ========= Structure related fields: ============
    /** The Team containing this role. */
	private TeamModel   _teamModel;

    /**
     * The corresponding roles from super-Teams.
     * This is a list, because for each level of nesting a new super team arises:
     * super, tsuper, tsuper-of-tsuper etc.
     * Examples:
     *   a role T2M2R1 may have these tsupers: T2M1R1 and T1M2R1
     *   a role O2T2M2R1 has these: O2T2M1R1, O2T1M2R1 and O1T2M2R1
     * All remaining roles R1 are indirect tsupers as they can be reached via any
     * of the above.
     */
    private ReferenceBinding[] _tsuperRoleBindings = new ReferenceBinding[2]; // 2 should suffice for human understandable programs ;-}
    private int numTSuperRoles = 0;

    /** this is set while role-splitting */
    public TypeDeclaration _interfacePart = null;

    /** this is set while role-splitting */
    public TypeDeclaration _classPart = null;

    private ReferenceBinding _interfaceBinding = null; // only internal cache
    private ReferenceBinding _classBinding = null;

    /** Record here all types which are defined local to a method (RoleModel). */
    private LinkedList<RoleModel> _localTypes = new LinkedList<RoleModel>();

	/** The known sub roles (including this) as determined by RoleHierarchyAnalyzer.analyze(). */
	private RoleModel[] _subRoles = null;

    /** bound roles store here the topmost bound (super)role, which determines the cache to use: */
    public RoleModel _boundRootRole = null;

    /** Collection of various flags. */
    public int tagBits = 0;

    /** will this role declare an abstract lower method? */
    public boolean _abstractLower = false;

    /** is this role refining the extends clause of its tsuper role? */
    public boolean _refinesExtends = false;

    /** does this bound role have a binding ambiguity prohibiting lifting? */
    public boolean _hasBindingAmbiguity = false;

    /** is the baseclass an (indirect) enclosing class? */
	public boolean _playedByEnclosing = false;

    /** map synthetic methods/fields of tsuper role to this role's */
    private HashMap<Binding, Binding> _syntheticMap = new HashMap<Binding, Binding>();

    /** is this role a local type? */
    public boolean _isLocalType;

	/** Remember which tsuper-features (methods & fields) have already been copied,
	 *  so that we can come back and copy more features (copyGeneratedFeatures)
	 *  without the risk of duplication.
	 */
	private HashSet<Binding> _copiedFeatureBindings = new HashSet<Binding>();


	/** Signal if a more specific role exists with unchanged playedBy. */
	public ReferenceBinding _supercededBy;


    /**
     * Constructor for use by BinaryTypeBinding only.
     */
    public RoleModel (ReferenceBinding roleBinding)
    {
        super(roleBinding);
        if (roleBinding.isLocalType())
        	this._isLocalType = true;
    }

    /**
     * Constructor for use by MemberTypeDeclaration only.
     */
    public RoleModel (TypeDeclaration roleAst)
    {
        super(roleAst);
        if (!TeamModel.isOrgObjectteamsTeam(roleAst.enclosingType))
        	addAttribute(WordValueAttribute.compilerVersionAttribute());
        if (roleAst.scope != null && roleAst.scope.parent instanceof MethodScope)
        	this._isLocalType = true;
    }

    public boolean hasState(int state) {
    	return this._state.getState() >= state;
	}

	/**  @return old state */
	@Override
	public int setState(int state) {
// FIXME(SH): should perhaps also set state of role-CUDs??
//            their state seems to skip many stages...
		int oldState = super.setState(state); // may also run pending jobs
		if (   oldState >= ITranslationStates.STATE_ROLE_FEATURES_COPIED
			&& state    <  ITranslationStates.STATE_BYTE_CODE_GENERATED)
		{
			// we are past STATE_ROLE_FEATURES_COPIED, take care to add generated features.
			// (This assumes, super team already has 'state').
			if (this._ast != null)
				CopyInheritance.copyGeneratedFeatures(this);
		}
// TODO(SH): enable only if needed, currently such behavior triggered only in setStateRecursive(CUD,state)
//    	if (   this._currentlyProcessingState == ITranslationStates.STATE_NONE
//        	&& this._requestedState > state)
//    	{
//    		this._currentlyProcessingState= this._requestedState;
//        	if (Dependencies.ensureRoleState(this, this._requestedState))
//        		this._requestedState= ITranslationStates.STATE_NONE;
//    	}
		return oldState;
	}

    /**
     * Override method from TypeModel:
     * Also recurse into role local types.
     */
	@Override
	public void setMemberState(int state) {
		super.setMemberState(state);
		if (   state <= ITranslationStates.STATE_ROLES_SPLIT
			|| state >= ITranslationStates.STATE_RESOLVED)
		{
	        Iterator<RoleModel> localTypes = localTypes();
	        while (localTypes.hasNext()) {
	        	RoleModel type = localTypes.next();
        		type.setState(state);
        		type.setMemberState(state);
	        }
		}
	}

	@Override
	public boolean isReadyToProcess(int state) {
		if (!this._state.isReadyToProcess(state))
			return false;
		// check the other model, too:
		RoleModel otherModel= null;
		if (this._interfaceBinding != null)
			otherModel= this._interfaceBinding.roleModel;
		if (otherModel == null || otherModel == this) {
			if (this._classBinding != null)
				otherModel= this._classBinding.roleModel;
		}
		if (otherModel != null && otherModel != this)
			return otherModel._state.isReadyToProcess(state);
		return true;
	}

	@Override
	public boolean isTeam() {
		if (this._ast != null)
			return this._ast.isTeam();
		return this._binding.isTeam();
	}

	public TeamModel getTeamModelOfThis() {
		// the class part has all the structure:
		getClassPartAst(); // initialize
		if (this._classPart != null && this._classPart.isTeam())
			return this._classPart.getTeamModel();
		getClassPartBinding(); // initialze
		if (this._classBinding != null && this._classBinding.isTeam())
			return this._classBinding.getTeamModel();
		return null;
	}


	public static boolean isClass(ReferenceBinding memberType) {
		if (!memberType.isRole())
			return memberType.isClass();
		ReferenceBinding realClass = memberType.getRealClass();
		return realClass != null && realClass.isClass();
	}


	public static boolean isInterface(ReferenceBinding memberType) {
		if (!memberType.isRole())
			return memberType.isInterface();
		// role can only be class or interface; test !class:
		ReferenceBinding realClass = memberType.getRealClass();
		return realClass == null || !realClass.isClass();
	}

	/** Is ifc the synthetic interface part of clazz? */
	public static boolean isSynthIfcOfClass(ReferenceBinding ifc, ReferenceBinding clazz) {
		if (ifc.isSynthInterface() && ifc.roleModel != null)
			if (TypeBinding.equalsEquals(ifc.roleModel.getClassPartBinding(), clazz))
				return true;
		return false;
	}


    public static void setTagBit(ReferenceBinding role, int tagBit) {
		role.roleModel.tagBits |= tagBit;
	}

	public static boolean hasTagBit(ReferenceBinding typeBinding, int tagBit) {
		if (typeBinding.roleModel == null)
			return false;
		return (typeBinding.roleModel.tagBits & tagBit) != 0;
	}

    // ================= Byte code related methods =========================

    /** Store byte code information of a method */
    public void recordByteCode (
            MethodBinding method,
            byte[] code,
            int offset,
            int[] constantPoolOffsets)
    {
        this._methodByteCodeOffsets.put(method, new Integer(offset));
        if (this._classByteCode == null) {
            this._classByteCode = code;
            this._constantPoolOffsets = constantPoolOffsets;
        } else {
            assert(this._classByteCode == code);
            // when registering from IBinaryType, the code will not be modified any more.
        }
    }

    /** Store byte code information of a method */
    public static void maybeRecordByteCode(
            AbstractMethodDeclaration method,
            ClassFile file,
            int codeAttributeOffset)
    {
        TypeDeclaration clazz = method.scope.referenceType();
        if (clazz.isRole())
        {
            TypeDeclaration memberType = clazz;
            RoleModel role = memberType.getRoleModel();
            role.recordClassFile(method.binding, file, codeAttributeOffset);
        }
    }

    /**
     * Is this role expected to have byte code?
     * Reasons for not having byte code originate in ignoreFurtherInvestigation
     * and may be propagated via MethodBinding.bytecodeMissing.
     * If no method with bytecode exists, no bytes have been recorded here.
     */
    public boolean hasByteCode() {
    	if (this._classByteCode != null || this._classFile != null || this._classFilePath != null)
    		return true;
    	TypeDeclaration ast = this._ast;
    	if (ast == null)
    		ast = this._binding.isInterface() ? this._interfacePart : this._classPart;
    	if (ast == null) return false;
    	if (TypeModel.isIgnoreFurtherInvestigation(ast)) return false;
    	MethodBinding[] methods= ast.binding.methods();
    	for (MethodBinding methodBinding : methods) {
			if (!methodBinding.bytecodeMissing)
				return true;
		}
    	return false;
    }
    /** Get the byte code of this role class.
     *  Must be registered with (maybe)recordByteCode
     */
    public synchronized byte[] getByteCode ()
    {
        if (this._classByteCode == null) {
        	if (this._classFile == null && this._ast != null)
        		this._classFile = this._ast.compilationResult.findClassFile(this._binding);
            if (this._classFile != null) // nullified once a class file is re-used for a different type
            {
            	this._classByteCode = this._classFile.getBytes();
            	this._headerOffset = this._classFile.headerOffset;
            } else {
            	// restore bytes from class file on disk:
            	try {
            		ClassFileReader reader = read();
	            	if (reader == null) {
	        			if (Config.getConfig().ignoreMissingBytecode)
	        				return null;
	            		throw new InternalCompilerError("Class file was not yet written to disk"); //$NON-NLS-1$
	            	}
                	this._classByteCode = reader.getBytes();
                	this._headerOffset = reader.getHeaderOffset();
                	this._constantPoolOffsets = reader.getConstantPoolOffsets();
				} catch (Exception e) {
					throw new InternalCompilerError("cannot retrieve generated class file: "+e); //$NON-NLS-1$
            	}
            }
        }
        assert(this._classByteCode != null);
        return this._classByteCode;
    }

    /** Get the byte code offsets of this role's constant pool.
     *  Must be registered with (maybe)recordByteCode
     */
    public int[] getConstantPoolOffsets()
    {
        if (this._constantPoolOffsets == null)
            restoreCPOffsets();
        return this._constantPoolOffsets;
    }

    /** Get the offset where in the byte code 'method' start.
     *  Must be registered with (maybe)recordByteCode
     *  @return method offset or -1 if source method has no byte code due to errors.
     */
    public int getByteCodeOffset (MethodBinding method)
    {
    	if (getByteCode() == null)
    		return -1;
        Integer offset = this._methodByteCodeOffsets.get(method.original());
        if (offset == null)
        {
            if(!method.bytecodeMissing)
                throw new InternalCompilerError("Method has no byte code: "+method); // unexpectedly! //$NON-NLS-1$
            return -1;
        }
        return offset.intValue() + this._headerOffset;
    }

    @Override
    public synchronized void setClassFilePath(String classFilePath) {
       	super.setClassFilePath(classFilePath);
       	this._classFile = null; // don't use any more but retrieve using the class file path
       	if (isTeam())
       		getTeamModelOfThis().setClassFilePath(classFilePath);
    }
    /**
     *  Currently unusable, since bytecode may be needed any time again!
     */
    public synchronized void forgetByteCode() {
        this._methodByteCodeOffsets = new HashMap<MethodBinding, Integer>();
        this._classFile           = null;
        this._classByteCode       = null;
        this._constantPoolOffsets = null;
    }

    private synchronized void recordClassFile(MethodBinding method, ClassFile file, int offset)
    {
        this._methodByteCodeOffsets.put(method, new Integer(offset));
        if (   (this._classFile != null)
            && (this._classFile != file))
        {
            throw new InternalCompilerError("wrong ClassFile instance."); //$NON-NLS-1$
        }
        this._classFile = file;
    }

    private void restoreCPOffsets() {
        try {
            byte[] code = getByteCode();
            if (code != null) {
                ClassFileReader reader
                    = new ClassFileReader(code, NO_SOURCE_FILE); // not recording OT-attributes
                this._constantPoolOffsets = reader.getConstantPoolOffsets();
            }
        } catch (ClassFormatException ex) {
            throw new InternalCompilerError(ex.toString());
        }
    }

    // =================== structure related methods: =================
	/**
	 * Role name: for normal roles (with ifc part) strip of the __OT__.
	 * @return the name
	 */
	public char[] getName() {
		return this._binding != null ?
			this._binding.sourceName() :
		    this._ast.name;
	}

	/**
	 * Is this a real role from source code (not role nested)?
	 */
	public boolean isSourceRole() {
		return this._ast != null ? this._ast.isSourceRole() : this._binding.isSourceRole();
	}

	/** Answer whether the role is purely copied (aka phantom role) are exists in source. */
	public boolean isPurelyCopied() {
		if (this._ast != null)
			return this._ast.isPurelyCopied;
		else
			return (this._extraRoleFlags & IOTConstants.OT_CLASS_PURELY_COPIED) != 0;
	}

	// can be role file and/or purely copied
	private int _extraRoleFlags = 0;
	public boolean isRoleFile() {
		if (this._ast == null)
			return (this._extraRoleFlags & IOTConstants.OT_CLASS_ROLE_FILE) != 0;
		return this._ast.isRoleFile();
	}

	public void setExtraRoleFlags(int flags) {
		this._extraRoleFlags = flags;
		// FIXME(SH): for role files also mark enclosing team (-> role files attribute)
	}

	public int getExtraRoleFlags() {
		return this._extraRoleFlags;
	}

	public boolean isLocalType() {
		if (this._binding != null)
			return this._binding.isLocalType();
		if (this._classBinding != null)
			return this._classBinding.isLocalType();
		if (this._ast != null && this._ast.scope != null)
			return (this._ast.scope.parent.kind == Scope.METHOD_SCOPE);
		return false;
	}

    public TypeDeclaration getInterfaceAst()
    {
    	if (this._interfacePart != null)
    		return this._interfacePart;
    	if (this._ast == null)
    		return null; // neither class nor ifc ast present, must be binary.
    	if (   this._interfaceBinding != null
    		&& !this._ast.isInterface())
    	{
    		RoleModel interfaceModel = this._interfaceBinding.roleModel;
    		if (interfaceModel != null && interfaceModel != this) // model sharing didn't work
    			return interfaceModel.getInterfaceAst();
    	}
    	if ((this._ast.bits & ASTNode.IsLocalType) != 0)
    		return null;
    	assert this._ast.isInterface();
    	return this._ast;
    }

    public TypeDeclaration getClassPartAst()
    {
    	if (this._classPart != null)
        	return this._classPart;
    	if (this._ast != null && !this._ast.isInterface())
    		return this._classPart = this._ast;
    	if (this._classBinding != null) {
    		RoleModel classRole = this._classBinding.roleModel;
    		if (classRole != null)
    			return this._classPart = classRole._ast;
    	}
    	return null;
    }

    public ReferenceBinding getInterfacePartBinding()
    {
        if (this._interfaceBinding == null) {
            if (this._interfacePart != null)
                this._interfaceBinding = this._interfacePart.binding;
            else if (this._binding != null && this._binding.enclosingType() != null)
                this._interfaceBinding = this._binding.enclosingType().getMemberType(
                    this._binding.sourceName()); // chop off OT_DELIM

            // Sanity check:
            if (   this._interfaceBinding  != null && this._binding != null
            	&& this._interfaceBinding.isBinaryBinding() != this._binding.isBinaryBinding()) {
            	Scope scope = null;
            	if (!this._binding.isBinaryBinding())
            		scope = ((SourceTypeBinding)this._binding).scope;
            	else if (!this._interfaceBinding.isBinaryBinding())
            		scope = ((SourceTypeBinding)this._interfaceBinding).scope;
            	String message = "Mismatching binary/source class/interface parts: "+String.valueOf(this._binding.readableName())+" / "+String.valueOf(this._interfaceBinding.readableName()); //$NON-NLS-1$ //$NON-NLS-2$
            	if (scope != null) {
					scope.problemReporter().mismatchingRoleParts(this._interfaceBinding, scope.referenceType());
            	} else
            		throw new InternalCompilerError(message);
            }

        }
        return this._interfaceBinding;
    }

	public ReferenceBinding getClassPartBinding()
	{
		if (this._classBinding == null) {
			if (this._binding == null) return null; // assuming error
	        if (!this._binding.isInterface())
			    this._classBinding = this._binding;
	        else if (this._binding.isSynthInterface()) {
	        	if (this._classPart != null)
	        		this._classBinding = this._classPart.binding;
	        	if (this._classBinding == null)
	        		this._classBinding = this._binding.enclosingType().getMemberType(
	        				CharOperation.concat(IOTConstants.OT_DELIM_NAME, this._binding.internalName()));
	        }
		}
        return this._classBinding;
	}

    public void setTeamModel(TeamModel teamModel) {
        this._teamModel = teamModel;
    }

    public TeamModel getTeamModel() {
        if (this._teamModel == null) {
        	try {
        		if (this._binding != null)
        			this._teamModel = TeamModel.getEnclosingTeam(this._binding).getTeamModel();
        		else // ROFI: fallback if team model is required before a binding is created:
        			this._teamModel = this._ast.enclosingType.getTeamModel();
        	} catch (NullPointerException npe) {
        		throw new InternalCompilerError("Missing enclosing team for "+this+"\n" //$NON-NLS-1$ //$NON-NLS-2$
        									     +(this._ast != null ? this._ast : this._binding));
        	}
        }
        return this._teamModel;
    }

    /**
     * Retrieve the tsuper role with highest priority.
     *
     * Note, that more tsuper roles may exist due to team nesting.
     * TODO (SH): need to check all callers, whether reading just the first
     * tsuper role is OK!
     *
     * @return first tsuper role or null
     */
    public ReferenceBinding getTSuperRoleBinding() {
		return this._tsuperRoleBindings[this.numTSuperRoles > 0 ? this.numTSuperRoles-1 : 0];
	}

    /** Answer all direct tsuper roles of this role in ascending priority. */
    public ReferenceBinding[] getTSuperRoleBindings() {
    	ReferenceBinding[] tsupers = new ReferenceBinding[this.numTSuperRoles];
    	System.arraycopy(this._tsuperRoleBindings, 0, tsupers, 0, this.numTSuperRoles);
    	return tsupers;
    }

    /** Does this role have any tsuper role, other than the predefined roles from Team? */
    public boolean hasRelevantTSuperRole() {
    	return    this.numTSuperRoles > 0
    	       && !TypeAnalyzer.isPredefinedRole(getBinding());
    }

	/**
	 * Is role some kind of tsuper role of current?
	 * It could be that any enclosing teams are role-and-tsuper-role.
	 * Then from there on inwards only role names are compared.
	 */
	public boolean hasTSuperRole(ReferenceBinding role) {
		if (!role.isRole())
			return false;
		ReferenceBinding otherClass = null, otherIfc = null;
		if(role.isInterface()) {
			otherIfc = role;
			otherClass = role.getRealClass();
		} else {
			otherIfc = role.getRealType();
			otherClass = role;
		}
		Dependencies.ensureRoleState(this, ITranslationStates.STATE_LENV_CONNECT_TYPE_HIERARCHY);
		for (int i = 0; i < this.numTSuperRoles; i++) {
			ReferenceBinding other = this._tsuperRoleBindings[i].isInterface() ? otherIfc : otherClass;
			if (TypeBinding.equalsEquals(this._tsuperRoleBindings[i], other))
				return true;
			if (this._tsuperRoleBindings[i].roleModel.hasTSuperRole(other))
				return true;
		}
		ReferenceBinding outerRole = this._binding.enclosingType();
		if (outerRole.isRole()) {
			ReferenceBinding roleOuter = role.enclosingType();
			if (!roleOuter.isRole())
				return false;
			if (!outerRole.roleModel.hasTSuperRole(roleOuter))
				return false;
			return CharOperation.equals(role.internalName(), this._binding.internalName());
		}
		return false;
	}

	@Override
	public void setBinding (ReferenceBinding binding) {
        this._binding = binding;
        binding.roleModel = this;
    }

    // -------------- local types -----------------

    /**
     * An binary local type was requested during resolve.
     * Maybe fix enclosingType and enter to _localTypes.
     *
     * @param local
     */
    public void addBinaryLocalType (ReferenceBinding local) {
		if (local instanceof BinaryTypeBinding) {
			((BinaryTypeBinding)local).setEnclosingOfRoleLocal(this._binding);
		}
		this._localTypes.add(local.roleModel);
    }

    /**
     * A local type was read from source code.
     * Record it as part (though not member) of this role.
     * @param local
     */
    public void addLocalType (char[] constantPoolName, RoleModel local) {
    	this._localTypes.add(local);
    	local._isLocalType = true;
    	if (constantPoolName != null) {
    		if (this._ast != null) {
    			Scope scope = this._ast.scope;
    			if (scope != null) {
    				CompilationUnitScope cuScope = scope.compilationUnitScope();
    				cuScope.registerLocalType(constantPoolName, local.getAst());
    			}
    		}
    	}
    	if (this._attributes != null)
    		for (AbstractAttribute attribute : this._attributes)
    			if (attribute.nameEquals(IOTConstants.ROLE_LOCAL_TYPES))
    				return;
    	addAttribute(new RoleLocalTypesAttribute(this));
    }

    /**
     * The method at [sourceStart-sourceEnd] was found to have errors.
     * Purge all recorded local types contained in that method (based on source positions).
     * @param sourceStart
     * @param sourceEnd
     */
	public void purgeLocalTypes(int sourceStart, int sourceEnd) {
		Iterator<RoleModel> iterator = this._localTypes.iterator();
		while (iterator.hasNext()) {
			RoleModel role = iterator.next();
			TypeDeclaration ast = role.getAst();
			if (ast != null && sourceStart < ast.sourceStart && ast.declarationSourceEnd < sourceEnd) {
				iterator.remove();
			}
		}
	}

	public void maybeAddLocalToEnclosing() {
		ReferenceBinding enclosing= this._binding.enclosingType();
		if (enclosing != null && enclosing.isRole()) {
			enclosing.roleModel.addBinaryLocalType(this._binding);
		}
	}
    /**
     * Get source type bindings for all local types ready to
     * write the RoleLocalTypesAttribute.
     *
     * @return a new non-null array
     */
    public ReferenceBinding[] getLocalTypes() {
    	ReferenceBinding[] types = new ReferenceBinding[this._localTypes.size()];
    	int j = 0;
    	for (int i=0; i<types.length; i++) {
    		types[j] = this._localTypes.get(i).getBinding();
    		if (types[j] != null)
    			j++;
    	}
    	if (j != types.length)
        	System.arraycopy(types, 0,
        					 types = new ReferenceBinding[j], 0,
							 j);
   		return types;
    }

    /**
     * Get role models of all recorded local types of this role.
     * Resolve these types if needed.
     */
	public Iterator<RoleModel> localTypes() {
		return this._localTypes.iterator();
	}

	/**
	 * Find a type by  its compound name.
	 * First look in local types (including enclosing roles).
	 * Second use the environment for lookup.
	 * This method is needed since local types are not stored in the environment.
	 *
	 * @param environment
	 * @param compoundName
	 * @return type specified by compoundName
	 */
	@Override
	public ReferenceBinding findType(LookupEnvironment environment, char[][] compoundName)
	{
		char[][] myName = CharOperation.splitOn('/', this._binding.constantPoolName());
		if (   this._binding.isLocalType()
			&& CharOperation.equals(compoundName, myName))
			return this._binding;
		Iterator<RoleModel> locals = localTypes();
		while (locals.hasNext()) {
			RoleModel role = locals.next();
			char[][] roleName = CharOperation.splitOn('/', role.getBinding().constantPoolName());
			if (CharOperation.equals(compoundName, roleName))
				return role.getBinding();
		}
		if (this._binding.enclosingType().isRole())
			return this._binding.enclosingType().roleModel.findType(environment, compoundName);
		return environment.getType(compoundName);
	}

	/**
	 * Similar to the above, but comparison is made be relative names, ie., team names
	 * as prefix are chopped of. Instead of an environment the scope of this role is used.
	 *
	 * @param compoundName
	 * @return type as specified by compoundName
	 */
	public ReferenceBinding findTypeRelative(char[] compoundName)
	{
		ReferenceBinding teamBinding = TeamModel.getEnclosingTeam(this._binding);
		if (this._binding.isLocalType())
		{
			if (TypeAnalyzer.equalRoleLocal(teamBinding, this._binding, compoundName))
				return this._binding;
		} else {
			if (CharOperation.equals(this._binding.internalName(), compoundName))
				return this._binding;
		}
		Iterator<RoleModel> locals = localTypes();
		while (locals.hasNext())
		{
			RoleModel role = locals.next();
			if (TypeAnalyzer.equalRoleLocal(teamBinding, role.getBinding(), compoundName))
				return role.getBinding();
		}
		if (this._binding.enclosingType().isRole())
			return this._binding.enclosingType().roleModel.findTypeRelative(compoundName);
		if (this._ast != null)
			return (ReferenceBinding)this._ast.scope.getType(compoundName);
		return null;
	}

	private boolean hasCheckedBaseclass= false; // caching the result the below method
	private boolean isBound; // --"--
	/**
	 * @return is this role bound to a base type?
	 */
    public boolean isBound() {
    	if (this.hasCheckedBaseclass)
    		return this.isBound;
    	this.hasCheckedBaseclass= true;
    	if (   this._ast != null
    		&& this._ast.baseclass != null)
    		return this.isBound= true;
        if (this._binding != null) {
            if (this._binding.rawBaseclass() != null)
            	return this.isBound= true;
            ReferenceBinding superRole = this._binding.superclass();
			if (   superRole != null
            	&& superRole.isRole()
            	&& superRole.roleModel.isBound())
				return this.isBound= true;
        }
        for (int i=0; i<this.numTSuperRoles; i++) {
        	if (this._tsuperRoleBindings[i].roleModel.isBound())
        		return this.isBound= true;
        }
        return this.isBound= false;
    }

    public boolean hasBaseclassProblem() {
    	if ((this.tagBits & BaseclassHasProblems) != 0)
    		return true;
    	ReferenceBinding binding = (this._classBinding != null) ? this._classBinding : this._binding;
    	if (binding.superclass() != null) {
    		ReferenceBinding superclass = binding.superclass();
    		if (   (   superclass.isRole()
    				&& superclass.isHierarchyInconsistent())
    			|| (   (superclass.roleModel != null)
    		        && (superclass.roleModel.hasBaseclassProblem())))
    		{
    			this.tagBits |= BaseclassHasProblems;
    			return true;
    		}
    	}
    	return false;
    }

    public static boolean isRoleWithBaseProblem(TypeDeclaration declaration) {
        if (!declaration.isSourceRole())
            return false;
        return declaration.getRoleModel().hasBaseclassProblem();
    }

    public ReferenceBinding getBaseTypeBinding() {
        return this._binding.baseclass();
    }

    /**
     * Is current a direct supertype of model?
     * Considers superClass and superInterfaces
     */
    public boolean isSuperTypeOf(RoleModel model) {
        if (this._binding.isSuperclassOf(model.getBinding()))
            return true;
        ReferenceBinding[] superInterfaces =
        	(model.getInterfacePartBinding() != null) ?
                model.getInterfacePartBinding().superInterfaces():
        		model.getClassPartBinding().superInterfaces();
        if (superInterfaces != null)
        {
            for (int i=0; i<superInterfaces.length; i++) {
                if (TypeBinding.equalsEquals(superInterfaces[i], this._binding))
                    return true;
            }
        }
        return false;
    }

	public RoleModel getExplicitSuperRole()
	{
		ReferenceBinding superClass = this._binding.superclass();
		if(superClass.superclass() == null)
		{
			//superClass is java.lang.Object
			return null;
		}
		return this._binding.superclass().roleModel;
	}

	public RoleModel getImplicitSuperRole()
	{
		if(getTSuperRoleBinding() == null)
		{
			return null;
		}
		return getTSuperRoleBinding().roleModel;
	}


	/**
	 * Give the most general role type on the path between this role
	 * and it's tsub version which is visible in 'scope'.
	 * @pre startRole.baseclass() != null
	 * @return non-null
	 */
	public static ReferenceBinding getTopmostBoundRole(BlockScope scope, ReferenceBinding startRole) {
		ReferenceBinding current = startRole;
		ReferenceBinding candidate = null;
		while (current != null) {
			if (!current.isRole())
				return candidate;
			if (current.baseclass() != null) // true at least in first iteration.
				candidate = current;
			else
				return candidate;
			current = current.roleModel.getTSuperRoleBinding();
		}
		return candidate;
	}

	public RoleModel getCopyInheritanceSource() {
		if (!isPurelyCopied())
			return this;
		for (int i = 0; i < this._tsuperRoleBindings.length; i++) {
			if (this._tsuperRoleBindings[i] != null) {
				RoleModel model = this._tsuperRoleBindings[i].roleModel.getCopyInheritanceSource();
				if (model != null)
					return model;
			}
		}
		throw new InternalCompilerError("Unable to find real tsuper role of phantom role "+this);
	}

	/**
	 * Store the known sub roles (including this) as determined by RoleHierarchyAnalyzer.analyze().
	 *
	 * @param subRoles
	 */
	public void setSubRoles(RoleModel[] subRoles) {
		this._subRoles = subRoles;
	}

	/**
	 * Retrieve the known sub roles (including this) as determined by RoleHierarchyAnalyzer.analyze().
	 */
	public RoleModel[] getSubRoles() {
		return this._subRoles;
	}


    RoleModel getSuperIfcRole(int idx) {
        if (getInterfacePartBinding().superInterfaces() == null)
            return null;
        if (getInterfacePartBinding().superInterfaces().length <= idx)
            return null;
        ReferenceBinding ifc = getInterfacePartBinding().superInterfaces()[idx];
        if (ifc.isSourceRole())
            return ifc.roleModel;
        return null;
    }

    int getNumSuperIfc () {
        if (this._binding.superInterfaces() == null)
            return 0;
        return this._binding.superInterfaces().length;
    }

    public boolean isSynthInterface() {
        int AccSynthIfc = AccInterface|AccSynthetic;
        return (this._binding.modifiers & AccSynthIfc) == AccSynthIfc;
    }


    public boolean isRegularInterface() {
        return this._binding.isRegularInterface();
    }

    public boolean equals(RoleModel other) {
    	if (other == null) return false;
    	if (this._interfaceBinding != null && other._interfaceBinding != null)
    		return TypeBinding.equalsEquals(this._interfaceBinding, other._interfaceBinding);
    	if (this._classBinding != null && other._classBinding != null)
    		return TypeBinding.equalsEquals(this._classBinding, other._classBinding);
    	return this._ast == other._ast;
    }
    /**
     * Record the interface part of a copied role.
     * @param roleIfcs map of interface indexed by name (String)
     */
    public void recordIfcPart(HashMap<String,TypeDeclaration> roleIfcs) {
        if (this._interfacePart == null) {
        	// defensively search the interface part's name:
            String ifcName = null;
            if (this._binding != null)
            	ifcName = new String(this._binding.sourceName());
            else if (this._ast != null) {
            	if (RoleSplitter.isClassPartName(this._ast.name))
            		ifcName = new String(RoleSplitter.getInterfacePartName(this._ast.name));
            }
            // on incredibly broken code, ifcName may still be null (see TPX-423).
            if (ifcName != null) {
            	this._interfacePart = roleIfcs.get(ifcName);
            	checkClassAndIfcParts();
            } else {
            	assert this._ast == null || this._ast.ignoreFurtherInvestigation : "should only ever happen one erroneous code"; //$NON-NLS-1$
            }
        }

    }

    public void checkClassAndIfcParts() {
    	boolean hasError = false;
    	Scope scope = null;
    	char[] ifcName = null;
    	char[] className = null;
		if (this._interfacePart != null && this._classPart != null) {
			scope = this._classPart.scope;
			ifcName = this._interfacePart.name;
			className = this._classPart.name;
			if (this._interfacePart.enclosingType != this._classPart.enclosingType)
				hasError = true;
		}
		if (this._interfaceBinding != null && this._classBinding != null) {
			// binding names contain more information:
			ifcName = this._interfaceBinding.readableName();
			className = this._classBinding.readableName();
			if (TypeBinding.notEquals(this._interfaceBinding.enclosingType(), this._classBinding.enclosingType()))
				hasError = true;
		}
		if (hasError) {
			if (scope == null)
				if (this._ast != null)
					scope = this._ast.scope;
			if (scope == null)
				throw new InternalCompilerError("Multiple errors processing role "+toString()); //$NON-NLS-1$
			scope.problemReporter().inconsistentlyResolvedRole(this._ast, ifcName, className);
		}
	}

	/**
     * Once team and tsuper role are known, record this information.
     */
    public void connect(TeamModel teamModel, ReferenceBinding tsuperRole) {
        setTeamModel(teamModel);
        ReferenceBinding superTeamBinding = teamModel.getBinding().superclass();
        if (superTeamBinding instanceof ParameterizedTypeBinding && !(tsuperRole instanceof ParameterizedTypeBinding)) {
        	LookupEnvironment env = Config.getLookupEnvironment();
        	if (env != null) {
        		tsuperRole = env.createParameterizedType(tsuperRole, null, superTeamBinding);
        		RoleModel.setTagBit(tsuperRole, RoleModel.IsViewedAsTSuper);
        	}
        }
        boolean tsuperAlreadyPresent = false;
        for (int i = 0; i < this.numTSuperRoles; i++) {
			if (TypeBinding.equalsEquals(this._tsuperRoleBindings[i], tsuperRole)) {
				tsuperAlreadyPresent = true;
				break;
			}
		}
        if (!tsuperAlreadyPresent) {
	        if (this.numTSuperRoles == this._tsuperRoleBindings.length)
	        	System.arraycopy(
	        			this._tsuperRoleBindings, 0,
	        			this._tsuperRoleBindings = new ReferenceBinding[2*this.numTSuperRoles], 0,
						this.numTSuperRoles);
	        this._tsuperRoleBindings[this.numTSuperRoles++] = tsuperRole;
	        if (getAst() != null && getAst().isInterface())
	        	TypeLevel.addImplicitInheritance(getAst(), tsuperRole);
	        int otClassFlags = IOTConstants.OT_CLASS_FLAG_HAS_TSUPER;
	        if (tsuperRole.roleModel.hasFinalFieldInit())
	        	otClassFlags |= IOTConstants.OT_CLASS_HAS_FINAL_FIELD_INITS;
			WordValueAttribute.addClassFlags(this, otClassFlags);
	        if (this._binding != null)
	        	this._binding.modifiers |= AccOverridingRole;
        }
    	// invoked from copy role we have at least this state:
        this._state.inititalize(ITranslationStates.STATE_ROLES_SPLIT);
    }

    public boolean hasFinalFieldInit() {
    	AbstractAttribute attribute = getAttribute(IOTConstants.OT_CLASS_FLAGS);
    	if (attribute instanceof WordValueAttribute) {
    		if ((((WordValueAttribute) attribute).getValue() & IOTConstants.OT_CLASS_HAS_FINAL_FIELD_INITS) != 0)
    			return true;
    	}
    	if (this._classPart != null && this._classPart.fields != null) {
    		for (FieldDeclaration field : this._classPart.fields) {
				if (field.initialization != null && field.isFinal())
					return true;
			}
    	}
    	return false;
    }

    @Override
	protected String getKindString() {
        return "Role"; //$NON-NLS-1$
    }

	/**
	 * @param srcMethod
	 * @param dstMethod
	 */
	public void addSyntheticMethodMapping(MethodBinding srcMethod, MethodBinding dstMethod) {
		this._syntheticMap.put(srcMethod, dstMethod);
	}

	public MethodBinding mapSyntheticMethod (MethodBinding srcMethod) {
		if (srcMethod instanceof SyntheticRoleFieldAccess) {
			// matching by name
			ReferenceBinding dstType = getBinding();
			if (dstType.isBinaryBinding())
				return null; // will be found within methods
			SyntheticMethodBinding[] synthetics = ((SourceTypeBinding)dstType).syntheticMethods();
			if (synthetics == null)
				return null;
			for (SyntheticMethodBinding methodBinding : synthetics) {
				if (CharOperation.equals(methodBinding.selector, srcMethod.selector))
					return methodBinding;
			}
			return null;
		} else {
			// matching by map
			return (MethodBinding)this._syntheticMap.get(srcMethod);
		}
	}

	/**
	 * @param srcField a synthetic field from tsuper
	 * @param newField the synthetic new field copy
	 */
	public void addSyntheticFieldMapping(FieldBinding srcField, FieldBinding newField) {
		this._syntheticMap.put(srcField, newField);
	}

	public FieldBinding mapSyntheticField(FieldBinding srcField) {
		return (FieldBinding)this._syntheticMap.get(srcField);
	}

	/**
     * Record that the given method is only accessible using decapsulation.
	 * @param binding
	 */
	public int addInaccessibleBaseMethod(MethodBinding binding) {
		// push out to the team to ensure early evaluation by the OTRE:
		OTSpecialAccessAttribute specialAccess = getTeamModel().getSpecialAccessAttribute();
		ReferenceBinding declaringClass = binding.declaringClass;
		specialAccess.addAdaptedBaseClass(declaringClass);
		ReferenceBinding baseclass = this._binding.baseclass();
		boolean visibleInBaseClass = true;
		if (getWeavingScheme() == WeavingScheme.OTDRE) {
			TypeBinding declaringOriginal = declaringClass.original();
			if (binding.isPrivate()) {
				visibleInBaseClass = TypeBinding.equalsEquals(baseclass.original(), declaringOriginal);
			} else if (binding.isDefault()) {
				PackageBinding tgtPackage = declaringClass.fPackage;
				ReferenceBinding currentType = baseclass;
				while (currentType != null && TypeBinding.notEquals(currentType.original(), declaringOriginal)) {
					if (tgtPackage != currentType.fPackage) {
						visibleInBaseClass = false;
						break;
					}
					currentType = currentType.superclass();
				}
			}
		}
		return specialAccess.addDecapsulatedMethodAccess(baseclass, binding, visibleInBaseClass);
	}

	/**
	 * Record that a given field is accessed using callout.
	 * @param field
	 * @param calloutModifier either TokenNameget or TokenNameset (from TerminalTokens).
	 * @return the accessId (per team) for this field
	 */
	public int addAccessedBaseField(FieldBinding field, int calloutModifier, CalloutToFieldDesc cpInheritanceSrc) {
		// find appropriate target class
		ReferenceBinding targetClass = field.declaringClass; // default: the class declaring the field (could be super of bound base)
		if (!field.isStatic() && (field.isProtected() || field.isPublic()))
			targetClass = getBaseTypeBinding();	// use the specific declared bound class (avoids weaving into possibly inaccessible super base)

		// push out to the team to ensure early evaluation by the OTRE:
		OTSpecialAccessAttribute specialAccess = getTeamModel().getSpecialAccessAttribute();
		int accessId = specialAccess.addCalloutFieldAccess(field, targetClass, calloutModifier, cpInheritanceSrc);
		specialAccess.addAdaptedBaseClass(field.declaringClass);
		return accessId;
	}

	/**
	 * Record that a base call needs access to the base.super-method.
	 * @param baseMethod
	 */
	public void addMethodSuperAccess(MethodBinding baseMethod) {
		OTSpecialAccessAttribute specialAccess = getTeamModel().getSpecialAccessAttribute();
		specialAccess.addSuperMethodAccess(baseMethod);
	}

	/**
	 * Record that an inaccessible base is bound.
	 * @param baseclass
	 */
	public void markBaseClassDecapsulation(ReferenceBinding baseclass) {
		// push out to the team to ensure early evaluation by the OTRE:
		OTSpecialAccessAttribute specialAccess = getTeamModel().getSpecialAccessAttribute();
		specialAccess.addBaseClassDecapsulation(baseclass);
	}

	/** Hook into attribute writing in order to insert callout mappings attribute. */
    @Override
	public int writeAttributes(ClassFile file) {
    	if (this._binding.callinCallouts != null) {
    		for (int i = 0; i < this._binding.callinCallouts.length; i++) {
				if (this._binding.callinCallouts[i].type != CallinCalloutBinding.CALLIN) // callout or -override
				{
					addAttribute(new CalloutMappingsAttribute(this));
					break;
				}
			}
    	}
    	return super.writeAttributes(file);
    }

	@Override
	public CPTypeAnchorAttribute getTypeAnchors() {
		return this._binding.model.getTypeAnchors();
	}

	public void setErrorFlag(boolean flag) {
		if (this._ast != null)
			this._ast.ignoreFurtherInvestigation = flag;
		if (this._classPart != null)
			this._classPart.ignoreFurtherInvestigation = flag;
		if (this._interfacePart != null)
			this._interfacePart.ignoreFurtherInvestigation = flag;
	}

	public void recordCopiedFeature(Binding feature) {
		this._copiedFeatureBindings.add(feature);
	}
	public boolean hasAlreadyBeenCopied(Binding feature) {
		return this._copiedFeatureBindings.contains(feature);
	}

	/** The Attributename of this role's baseclass as it is used in bytecode attributes.
	 *  PRE: this is a bound role.
	 *  @param includeAnchor should anchored types be encoded in full?
	 */
	public char[] getBaseclassAttributename(boolean includeAnchor) {
		ReferenceBinding baseclass = getBinding().baseclass();
		char[] baseName = baseclass.getRealClass().attributeName();
		if (includeAnchor && RoleTypeBinding.isRoleWithExplicitAnchor(baseclass))
			return CharOperation.concat(baseName,
				   CharOperation.concat(SingleValueAttribute.ANCHOR_DELIM,
				   CharOperation.append(((RoleTypeBinding)baseclass)._teamAnchor.getBestName(), '>')));
		return baseName;
	}

	/* (non-Javadoc)
     * @see org.eclipse.objectteams.otdt.internal.core.compiler.model.TypeModel#cleanup()
     */
    @Override
	public void cleanup()
    {
        super.cleanup();
        this._copiedFeatureBindings = null;
    }

	public RoleModel getBoundRootRole() {
		if (this._boundRootRole != null)
			return this._boundRootRole;
		if (this._binding.isInterface() && this._classBinding != null)
		{
			RoleModel classPart = this._classBinding.roleModel;
			return classPart.getBoundRootRole();
		}
		return null;
	}

	public static int getDeclaredModifiers(ReferenceBinding typeBinding) {
		if (!typeBinding.isRole() || typeBinding.roleModel == null)
			return typeBinding.modifiers;
		ReferenceBinding classPartBinding = typeBinding.roleModel.getClassPartBinding();
		if (classPartBinding != null)
			return classPartBinding.modifiers;
		return typeBinding.modifiers;
	}

	public static boolean isRoleFromOuterEnclosing(SourceTypeBinding sourceType,
												   ReferenceBinding baseclass)
	{
		ReferenceBinding enclosingTeam = sourceType.enclosingType();
		if (enclosingTeam == null || !enclosingTeam.isTeam())
			return false;
		if (TypeBinding.equalsEquals(enclosingTeam, baseclass.enclosingType()))
			return false;
		while (true) {
			enclosingTeam = enclosingTeam.enclosingType();
			if (enclosingTeam == null || !enclosingTeam.isTeam())
				return false;
			if (TypeBinding.equalsEquals(enclosingTeam, baseclass.enclosingType()))
				return true;
		}
	}

	public boolean hasCallins() {
		if (this._attributes == null)
			return false;
		for (AbstractAttribute attribute : this._attributes)
			if (attribute.nameEquals(IOTConstants.CALLIN_METHOD_MAPPINGS)) {
				// don't report if all callins are inherited:
				if (!((CallinMethodMappingsAttribute)attribute).isInherited())
					return true;
			}

		return false;
	}

	/**
	 * After attributes are evaluated, each role class must check, whether it is
	 * supposed to implement method mappings inherited from a super interface.
	 */
	public void implementMethodBindingsFromSuperinterfaces() {
		if (this._ast == null || this._ast.isInterface() || this._binding == null || this._binding.isLocalType())
			return;
		ReferenceBinding interfacePartBinding = getInterfacePartBinding();
		if (interfacePartBinding == null) // paranoia
			return;
		ReferenceBinding[] superInterfaces = interfacePartBinding.superInterfaces();
		if (superInterfaces == null) // paranoia (null seen in real life)
			return;
		for (ReferenceBinding superInterface : superInterfaces)
		{
			if (!superInterface.isRole())
				continue;
			if (superInterface.roleModel.getState() < ITranslationStates.STATE_LATE_ATTRIBUTES_EVALUATED-1)
				continue; // not yet prepared
			if (!Dependencies.ensureBindingState(superInterface, ITranslationStates.STATE_LATE_ATTRIBUTES_EVALUATED))
				continue;
			CallinCalloutBinding[] methodMappings = superInterface.callinCallouts;
			if (methodMappings != null)
				for (CallinCalloutBinding mapping : methodMappings)
					if (mapping.isValidBinding() && mapping.isCallout())
						new CalloutImplementor(this).generateFromBinding(mapping);
		}
	}

	@Override
	public void evaluateLateAttributes(int state) {
		if (state == ITranslationStates.STATE_LATE_ATTRIBUTES_EVALUATED) {
			for (ReferenceBinding tsuperRole : this.getTSuperRoleBindings())
				Dependencies.ensureBindingState(tsuperRole, ITranslationStates.STATE_LATE_ATTRIBUTES_EVALUATED);
		}
		if (this._ast != null)
			CopyInheritance.copyGeneratedFeatures(this);
		super.evaluateLateAttributes(state);
	}

	public synchronized void releaseClassFile() {
		this._classFile= null;
	}

	/**
	 * Starting with this role look for subtypes that are bound, returning all top-bound roles.
	 * @return non-null
	 */
	public ReferenceBinding[] getBoundDescendants() {
		if (this._binding == null)
			return new ReferenceBinding[0];
		if (this._binding.baseclass() != null)
			return new ReferenceBinding[]{this._binding};

		ArrayList<ReferenceBinding> roles = new ArrayList<ReferenceBinding>();
		for (ReferenceBinding knownRole: getTeamModel().getKnownRoles()) {
			if (knownRole.baseclass() == null) 				continue; // not bound
			if (!knownRole.isCompatibleWith(this._binding)) continue; // not compatible
			if (knownRole.superclass().baseclass() != null) continue; // not top
			if (knownRole.isClass()) 						continue; // only record ifc to avoid dupes
			roles.add(knownRole);
		}
		return roles.toArray(new ReferenceBinding[roles.size()]);
	}

	/** recored here any unimplemented getBase method:
	 *    <_OT$AnyBase base R> _OT$getBase() { throw new AbstractMethodError(); }
	 */
	public MethodBinding unimplementedGetBase;
	/**
	 * If an unbound super role exists return its unimplemented getBase method.
	 */
	public MethodBinding getInheritedUnimplementedGetBase() {
		ReferenceBinding classPartBinding = getClassPartBinding();
		if (classPartBinding != null) {
			ReferenceBinding superclass = classPartBinding.superclass();
			while (superclass != null && superclass.isRole()) {
				RoleModel superRole = superclass.roleModel;
				if (superRole.unimplementedGetBase != null)
					return superRole.unimplementedGetBase;
				superclass = superclass.superclass();
			}
		}
		return null;
	}

	public static Lifting.InstantiationPolicy getInstantiationPolicy(ReferenceBinding roleClassBinding) {
		if ((roleClassBinding.getAnnotationTagBits() & TagBits.AnnotationInstantiation) != 0) {
			for (AnnotationBinding annotation : roleClassBinding.getAnnotations()) {
				if (annotation.getAnnotationType().id == IOTConstants.T_OrgObjectTeamsInstantiation) {
					for (ElementValuePair pair : annotation.getElementValuePairs()) {
						if (pair.value instanceof FieldBinding) {
							String name = String.valueOf(((FieldBinding) pair.value).name);
							try {
								return InstantiationPolicy.valueOf(name);
							} catch (IllegalArgumentException iae) {
								return InstantiationPolicy.ERROR;
							}
						}
					}
				}
			}
		}
		return InstantiationPolicy.ONDEMAND; // default
	}

	public static boolean areTypeParametersOfSameRole(TypeVariableBinding one, Binding two) {
		if (!(two instanceof TypeVariableBinding))
			return false;
		Binding declaring1 = one.declaringElement;
		Binding declaring2 = ((TypeVariableBinding)two).declaringElement;
		if (   !(declaring1 instanceof ReferenceBinding)
			|| !(declaring2 instanceof ReferenceBinding))
			return false;
		return TypeBinding.equalsEquals(((ReferenceBinding)declaring1).getRealType(), ((ReferenceBinding)declaring2).getRealType());
	}

	public void markCallinOverride(char[] name, RoleModel subRole) {
		if (this._ast == null || this._ast.callinCallouts == null)
			return;
		for (AbstractMethodMappingDeclaration mapping : this._ast.callinCallouts) {
			if (mapping instanceof CallinMappingDeclaration) {
				CallinMappingDeclaration callin = (CallinMappingDeclaration) mapping;
				if (callin.hasName() && CharOperation.equals(name, callin.name)) {
					callin.isOverriddenInTeam = true;
					this._ast.scope.problemReporter().callinOverriddenInTeam(callin, subRole);
				}
			}
		}
	}
}