| /********************************************************************** |
| * This file is part of "Object Teams Development Tooling"-Software |
| * |
| * Copyright 2004, 2016 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 |
| * |
| * 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 java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.util.HashSet; |
| import java.util.LinkedList; |
| import java.util.List; |
| |
| import org.eclipse.jdt.core.compiler.CharOperation; |
| import org.eclipse.jdt.internal.compiler.ast.ASTNode; |
| import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration; |
| 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.BinaryTypeBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.Binding; |
| import org.eclipse.jdt.internal.compiler.lookup.ClassScope; |
| import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment; |
| import org.eclipse.jdt.internal.compiler.lookup.MethodScope; |
| 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.UnresolvedReferenceBinding; |
| import org.eclipse.jdt.internal.compiler.problem.AbortCompilation; |
| import org.eclipse.jdt.internal.compiler.util.Util; |
| import org.eclipse.objectteams.otdt.core.compiler.IOTConstants; |
| import org.eclipse.objectteams.otdt.core.exceptions.InternalCompilerError; |
| import org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.CPTypeAnchorAttribute; |
| import org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.OTSpecialAccessAttribute; |
| import org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.ReferencedTeamsAttribute; |
| import org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.RoleFilesAttribute; |
| import org.eclipse.objectteams.otdt.internal.core.compiler.bytecode.WordValueAttribute; |
| 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.control.StateMemento; |
| import org.eclipse.objectteams.otdt.internal.core.compiler.lookup.ITeamAnchor; |
| import org.eclipse.objectteams.otdt.internal.core.compiler.smap.LineNumberProvider; |
| import org.eclipse.objectteams.otdt.internal.core.compiler.util.TypeAnalyzer; |
| |
| /** |
| * Generalizes TeamModel and RoleModel |
| * @author stephan |
| */ |
| public class TypeModel extends ModelElement { |
| |
| /* Constructor for regular instances. */ |
| public TypeModel (TypeDeclaration ast) { |
| this._ast = ast; |
| int[] lineSeparatorPositions = ast.compilationResult.lineSeparatorPositions; |
| if (lineSeparatorPositions != null) { |
| this._maxLineNumber = Util.getLineNumber(ast.declarationSourceEnd, lineSeparatorPositions, 0, lineSeparatorPositions.length-1); |
| } else if ( !ast.isConverted |
| && !ast.isGenerated |
| && Dependencies.needMethodBodies(ast)) |
| { |
| throw new InternalCompilerError("Unexpectedly missing line number information"); //$NON-NLS-1$ |
| } |
| this._state = new StateMemento(); |
| } |
| /* Constructor for regular instances. */ |
| public TypeModel (ReferenceBinding bind) { |
| this._binding = bind; |
| this._state = new StateMemento(); |
| } |
| /** clone constructor: */ |
| public TypeModel (TypeModel prototype, ReferenceBinding protoBinding) { |
| this._binding = protoBinding; |
| this._state = prototype._state; |
| this._compilerVersion = prototype._compilerVersion; |
| this.weavingScheme = prototype.weavingScheme; |
| this._ast = prototype._ast; |
| } |
| |
| /** Store the byte code attribute which maps constant pool entries (Class_info) to type anchors. */ |
| private CPTypeAnchorAttribute _typeAnchors; |
| |
| /** Mediate RoleFilesAttribute to RoleFileCache. */ |
| public RoleFilesAttribute _roleFilesAttribute = null; |
| |
| /** Backward reference for the Ast being wrapped. */ |
| protected TypeDeclaration _ast; |
| |
| protected ReferenceBinding _binding; |
| |
| private HashSet<ReferenceBinding> _referencedTeams = null; |
| |
| /** translation state of this model element */ |
| final public StateMemento _state; |
| |
| /** Record here all types which are defined local to a method (TypeDeclaration). */ |
| private LinkedList<TypeDeclaration> _localPlainTypes = new LinkedList<TypeDeclaration>(); |
| |
| public int _maxLineNumber = 0; |
| |
| /** |
| * Needed for JSR-045 support. |
| * Can be asked for new line numbers(above linenumberrange) and stores mapping. |
| */ |
| protected LineNumberProvider _lineNumberProvider; |
| |
| /** |
| * Version number of the compiler that created a (binary) type; |
| */ |
| public int _compilerVersion; |
| |
| WeavingScheme weavingScheme; |
| |
| public void setCompilerVersion(int version, WeavingScheme weavingScheme) { |
| this._compilerVersion = version; |
| this.weavingScheme = weavingScheme; |
| } |
| |
| public void setBinding (ReferenceBinding binding) { |
| this._binding = binding; |
| binding.model = this; |
| } |
| /** |
| * @return The class-part of the AST being wrapped. May be null!! |
| */ |
| public TypeDeclaration getAst() { |
| return this._ast; |
| } |
| public ReferenceBinding getBinding() { |
| if (this._binding == null && this._ast != null && this._ast.binding != null) |
| setBinding(this._ast.binding); |
| return this._binding; |
| } |
| |
| /** |
| * Get all members which are not roles represented by their TypeModel. |
| * Considers Ast or Bindings, whatever is more appropriate. |
| * Note, that members could again be teams. |
| * |
| * @returns all members for this Team. |
| */ |
| public TypeModel[] getMembers() |
| { |
| List<TypeModel> list = new LinkedList<TypeModel>(); |
| |
| if(this._ast == null) |
| { |
| if ( this._binding.kind() == Binding.TYPE_PARAMETER |
| || this._binding.kind() == Binding.WILDCARD_TYPE |
| || this._binding.kind() == Binding.INTERSECTION_TYPE |
| || this._binding.kind() == Binding.INTERSECTION_TYPE18) |
| return new TypeModel[0]; // has no members |
| |
| if (this._binding.isUnresolvedType()) |
| return new TypeModel[0]; // members unknown and cannot resolve here :( |
| |
| //binary type |
| assert this._binding.isBinaryBinding(); |
| // don't used memberTypes() as not to trigger resolving unneeded members. |
| // see tests.compiler.regegression.LookupTest.test044 |
| ReferenceBinding[] memberBindings = ((BinaryTypeBinding)this._binding).unresolvedMemberTypes(); |
| for (int i = 0; i < memberBindings.length; i++) |
| { |
| ReferenceBinding binding = memberBindings[i]; |
| if (binding instanceof UnresolvedReferenceBinding) |
| continue; // has no model yet cannot handle yet. |
| if (binding.isTeam()) |
| list.add(binding.getTeamModel()); |
| else |
| list.add(binding.model); |
| } |
| } |
| else |
| { |
| TypeDeclaration[] members = this._ast.memberTypes; |
| if (members != null) |
| { |
| for (int idx = 0; idx<members.length; idx++) |
| { |
| TypeDeclaration decl = members[idx]; |
| if (decl.isTeam()) |
| list.add(decl.getTeamModel()); |
| else if (decl.isRole()) |
| list.add(decl.getRoleModel()); |
| else |
| list.add(decl.getModel()); |
| } |
| } |
| |
| AbstractMethodDeclaration[] methods = this._ast.methods; |
| if (methods != null) { |
| for (int i=0; i<methods.length; i++) { |
| if (methods[i] != null && methods[i].scope != null) { |
| ClassScope[] scopes = methods[i].scope.getAllLocalTypes(); |
| for (int j=0; j<scopes.length; j++) { |
| TypeDeclaration type = scopes[j].referenceContext; |
| if (type.isTeam()) // very unlikely ;-) |
| list.add(type.getTeamModel()); |
| else if (type.isRole()) |
| list.add(type.getRoleModel()); |
| else |
| list.add(type.getModel()); |
| } |
| } |
| // no scope could mean: |
| // 1. it's a <clinit> |
| // 2. we are before scope creation |
| // (which happens in completeTypeBindings(), last step of beginToCompile). |
| // This is ok, since then we only miss step RoleSplitter, but local types |
| // cannot be teams with roles anyway. |
| } |
| } |
| } |
| return list.toArray(new TypeModel[list.size()]); |
| } |
| |
| 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; |
| if ( this._binding.enclosingType() != null |
| && this._binding.enclosingType().isRole()) |
| return this._binding.enclosingType().roleModel.findType(environment, compoundName); |
| return environment.getType(compoundName); |
| } |
| |
| public char[] getInternalName() { |
| if (this._ast != null) |
| return this._ast.name; |
| else |
| return this._binding.internalName(); |
| } |
| |
| |
| public void cleanup() { |
| this._ast = null; |
| this._lineNumberProvider = null; |
| } |
| |
| public void addLocalType(TypeDeclaration localType) { |
| this._localPlainTypes.add(localType); |
| } |
| |
| // === state handling: === |
| |
| public int getState() { |
| return this._state.getState(); |
| } |
| |
| /** |
| * Include local types in set state. |
| */ |
| public int setState(int state) { |
| int oldState= this._state.setState(state); |
| for (TypeDeclaration localType : this._localPlainTypes) |
| if (localType.getModel().getState() >= ITranslationStates.STATE_RESOLVED) |
| localType.getModel().setState(state); |
| this._state.runPendingJobs(state); |
| return oldState; |
| } |
| |
| public void setMemberState(int state) { |
| TypeModel[] members = getMembers(); |
| if (members != null) |
| { |
| for (int i=0; i<members.length; i++) |
| { |
| TypeModel member = members[i]; |
| member.setMemberState(state); |
| member.setState(state); |
| } |
| } |
| } |
| |
| public boolean isReadyToProcess(int state) { |
| return this._state.isReadyToProcess(state); |
| } |
| |
| public boolean isTeam() { |
| return false; |
| } |
| public boolean isRole() { |
| if (this._binding != null) |
| return this._binding.isRole(); |
| return this._ast.isRole(); |
| } |
| |
| protected String getKindString() { |
| return "Class "; //$NON-NLS-1$ |
| } |
| |
| @Override |
| @SuppressWarnings("nls") |
| public String toString() { |
| String name = (this._ast != null) ? |
| new String(this._ast.name) : |
| new String(this._binding.sourceName()); |
| return getKindString()+" "+name |
| + " (state: " + this._state +")"; |
| } |
| |
| /** |
| * Check whether a binding found by getTypeOrPackage is a team, |
| * and if so, record it as a referenced team of this type. |
| * |
| * @param binding |
| * @param scope site where reference was found |
| */ |
| public static void checkReferencedTeam(Binding binding, Scope scope) { |
| if (!(binding instanceof ReferenceBinding)) |
| return; |
| ReferenceBinding type = (ReferenceBinding)binding; |
| if (!type.isTeam()) |
| return; |
| // is binding an enclosing type of scope? |
| ReferenceBinding currentType = scope.enclosingSourceType(); |
| while (currentType != null) { |
| if (currentType == binding) |
| return; // no need to record self-reference |
| currentType = currentType.enclosingType(); |
| } |
| while (scope != null) { |
| TypeDeclaration site = scope.referenceType(); |
| if (site == null) |
| return; |
| site.getModel().registerReferencedTeam(type); |
| scope = scope.parent; |
| } |
| } |
| |
| /** |
| * Mark that the current class references the given team type. |
| * @param teamType |
| */ |
| private void registerReferencedTeam(ReferenceBinding teamType) { |
| if (TypeAnalyzer.isOrgObjectteamsTeam(teamType)) |
| return; // optimize since Team has no bindings. |
| if (this._referencedTeams == null) { |
| this._referencedTeams = new HashSet<ReferenceBinding>(); |
| addAttribute(new ReferencedTeamsAttribute(this)); |
| } |
| this._referencedTeams.add(teamType); |
| } |
| |
| /** |
| * Retrieve the gathered data about referenced teams. |
| * @return Object[] containing ReferenceBindings |
| */ |
| public ReferenceBinding[] getReferencedTeams() { |
| return this._referencedTeams.toArray(new ReferenceBinding[this._referencedTeams.size()]); |
| } |
| |
| public boolean isIgnoreFurtherInvestigation() { |
| if (this._ast == null) |
| return false; |
| return TypeModel.isIgnoreFurtherInvestigation(this._ast); |
| } |
| public static boolean isIgnoreFurtherInvestigation(TypeDeclaration type) |
| { |
| if (type.ignoreFurtherInvestigation) |
| return true; |
| if ( type.compilationUnit != null |
| && type.compilationUnit.ignoreFurtherInvestigation) |
| return true; |
| if ( type.scope != null |
| && type.scope.cuIgnoreFurtherInvestigation()) |
| return true; |
| if ( type.enclosingType != null |
| && type.enclosingType.ignoreFurtherInvestigation) |
| return true; |
| if((type.bits & ASTNode.IsLocalType)!=0 && type.scope != null) { |
| MethodScope outerMostMethodScope = type.scope.outerMostMethodScope(); |
| if (outerMostMethodScope != null) { |
| if (outerMostMethodScope.referenceContext instanceof AbstractMethodDeclaration) |
| { // weired: MethodScope.referenceContext can be a TypeDeclaration!?! |
| AbstractMethodDeclaration method = (AbstractMethodDeclaration)outerMostMethodScope.referenceContext; |
| if ( method != null |
| && method.ignoreFurtherInvestigation) |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Has this type been compiled with an old compiler, |
| * meaning byte code is not compatible to current commpiler? |
| * |
| * Should only be used when a problem has already been detected, |
| * because we might be over-cautious here which means a <code>true</code> |
| * answer from this method does not necessarily imply actual incompatibility. |
| */ |
| public boolean isIncompatibleCompilerVersion() { |
| // require major and minor to match the current compiler, for now. |
| int minVersion = (IOTConstants.OTVersion.getMajor() << 9) |
| + (IOTConstants.OTVersion.getMinor() << 5); |
| return this._compilerVersion < minVersion; |
| } |
| |
| public CPTypeAnchorAttribute getTypeAnchors() { |
| return this._typeAnchors; |
| } |
| /** |
| * Note: this setter is overridden in RoleModel |
| */ |
| public void setTypeAnchors(CPTypeAnchorAttribute attribute) { |
| this._typeAnchors = attribute; |
| } |
| public void addTypeAnchor(ITeamAnchor anchor, int cpIndex) { |
| if (this._typeAnchors == null) { |
| this._typeAnchors = new CPTypeAnchorAttribute(); |
| addAttribute(this._typeAnchors); |
| } |
| this._typeAnchors.addTypeAnchor(anchor, cpIndex); |
| } |
| |
| /** |
| * Some attributes can only be evaluated after translation reaches a specific state |
| * at end of FAULT_IN_TYPES: |
| * CallinMethodMappingAttribute, CalloutMethodMappingAttribute |
| * task of LATE_ATTRIBUTES_EVALUATED: |
| * CopyInheritanceSrc (roles) |
| * CallinPrecedence (teams) |
| */ |
| public void evaluateLateAttributes(int state) { |
| try { |
| try { |
| if (this._binding != null && this._binding.isBinaryBinding()) { |
| if (this._attributes != null) { |
| for (int i = 0; i < this._attributes.length; i++) { |
| this._attributes[i].evaluateLateAttribute(this._binding, state); |
| } |
| } |
| } |
| } catch (AbortCompilation ac) { |
| // abort may e.g. happen if a binary tsuper role is inconsistent. |
| TypeDeclaration type = this._ast; |
| if (type == null) { |
| ReferenceBinding enclosing = this._binding.enclosingType(); |
| if (enclosing != null && !enclosing.isBinaryBinding()) |
| type = enclosing.model.getAst(); |
| } |
| if (type != null) |
| ac.updateContext(type, type.compilationResult); |
| throw ac; |
| } |
| if (this._binding != null) { |
| ReferenceBinding[] memberTypes = this._binding.memberTypes(); |
| if (memberTypes != null) { |
| for (int i = 0; i < memberTypes.length; i++) { |
| ModelElement.evaluateLateAttributes(memberTypes[i], state); |
| } |
| } |
| } |
| } finally { |
| // don't advance the state when working on behalf of another state |
| if (state == ITranslationStates.STATE_LATE_ATTRIBUTES_EVALUATED) |
| setState(ITranslationStates.STATE_LATE_ATTRIBUTES_EVALUATED); |
| } |
| } |
| // ==== allow to re-read bytes from the written class file ==== |
| // See comment in ClassFile (near field "generatingModel"). |
| |
| protected String _classFilePath = null; |
| |
| /** Store different elements accessed by this class, which require special treatment: |
| * methods and base-classes requiring decapsulation. |
| * fields requiring a getter and/or setter. |
| */ |
| protected OTSpecialAccessAttribute _specialAccess = null; |
| |
| /** |
| * @param classFilePath |
| */ |
| public void setClassFilePath(String classFilePath) { |
| this._classFilePath = classFilePath; |
| } |
| public ClassFileReader read () throws IOException, ClassFormatException |
| { |
| if (this._classFilePath != null) { |
| FileNotFoundException fileNotFoundException = null; |
| for (int i=0; i<5; i++) { // make <= 5 attempts thus waiting <= 500 ms |
| try { |
| return ClassFileReader.read(this._classFilePath); // not recording attributes |
| } catch (FileNotFoundException ex) { |
| fileNotFoundException = ex; |
| try { |
| Thread.sleep(100); |
| } catch (InterruptedException e) { |
| e.printStackTrace(); |
| } |
| } |
| } |
| if (fileNotFoundException != null) |
| throw fileNotFoundException; |
| } |
| return null; |
| } |
| /** |
| * supports CALLIN_METHOD_MAPPINGS_ATTRIBUTE and STATE_REPLACE_BINDINGS_ATTRIBUTE |
| * @param superDeclaringType represents the type from which the attribute is being copied |
| * @param attributeName |
| */ |
| public void copyAttributeFrom(TypeModel superDeclaringType, char[] attributeName) { |
| if (superDeclaringType._attributes == null) |
| return; |
| for (int i = 0; i < superDeclaringType._attributes.length; i++) { |
| if (superDeclaringType._attributes[i].nameEquals(attributeName)) { |
| addOrMergeAttribute(superDeclaringType._attributes[i]); |
| return; |
| } |
| } |
| } |
| |
| public void setSpecialAccess(OTSpecialAccessAttribute attribute) { |
| assert this._specialAccess == null; |
| this._specialAccess = attribute; |
| } |
| public OTSpecialAccessAttribute getSpecialAccessAttribute() { |
| if (this._specialAccess == null) { |
| this._specialAccess = new OTSpecialAccessAttribute(this._binding, getWeavingScheme()); |
| addAttribute(this._specialAccess); |
| } |
| return this._specialAccess; |
| } |
| |
| public LineNumberProvider getLineNumberProvider() { |
| if (this._lineNumberProvider == null) |
| this._lineNumberProvider = new LineNumberProvider(this._binding, this._maxLineNumber); |
| return this._lineNumberProvider; |
| } |
| |
| public static LineNumberProvider getLineNumberProvider(TypeDeclaration type) { |
| if (type.isRole()) |
| return type.getRoleModel().getLineNumberProvider(); |
| if (type.isTeam()) |
| return type.getTeamModel().getLineNumberProvider(); |
| return type.getModel().getLineNumberProvider(); |
| } |
| |
| public static boolean isConverted(ReferenceBinding declaringClass) { |
| TypeDeclaration result; |
| if (declaringClass instanceof SourceTypeBinding) { |
| Scope scope = ((SourceTypeBinding) declaringClass).scope; |
| if (scope != null && scope.referenceType() != null) |
| return scope.referenceType().isConverted; |
| } |
| // TODO(SH): the rest of this method is probably obsoleted the above |
| if (declaringClass.isRole()) { |
| RoleModel roleModel = declaringClass.roleModel; |
| if (roleModel != null) { |
| if ( (result = roleModel.getClassPartAst()) != null |
| && result.isConverted) |
| return true; |
| if ( (result = roleModel.getInterfaceAst()) != null |
| && result.isConverted) |
| return true; |
| } |
| } |
| if (declaringClass.isTeam()) { |
| TeamModel teamModel = declaringClass.getTeamModel(); |
| if (teamModel != null) { |
| if ( (result = teamModel.getAst()) != null |
| && result.isConverted) |
| return true; |
| } |
| } |
| return false; |
| } |
| public WeavingScheme getWeavingScheme() { |
| if (this.weavingScheme == null && this._ast != null && this._ast.scope != null) { |
| this.weavingScheme = this._ast.scope.compilerOptions().weavingScheme; |
| if (this.weavingScheme == WeavingScheme.OTDRE) { |
| if (this._attributes != null) |
| for (int i = 0; i < this._attributes.length; i++) |
| if (this._attributes[i].nameEquals(IOTConstants.OT_COMPILER_VERSION)) { |
| ((WordValueAttribute)this._attributes[i]).setWeavingScheme(this.weavingScheme); |
| break; |
| } |
| } |
| } |
| return this.weavingScheme; |
| } |
| } |
