/** * Check that the set of <code>LocalInstance</code>s <code>localsUsed</code>, which is the set of * locals used in the inner class declared by <code>cb</code> are initialized before the class * declaration. */ protected void checkLocalsUsedByInnerClass( FlowGraph graph, ClassBody cb, Set localsUsed, DataFlowItem dfIn, DataFlowItem dfOut) throws SemanticException { for (Iterator iter = localsUsed.iterator(); iter.hasNext(); ) { LocalInstance li = (LocalInstance) iter.next(); MinMaxInitCount initCount = (MinMaxInitCount) dfOut.initStatus.get(li); if (!currCBI.localDeclarations.contains(li)) { // the local wasn't defined in this scope. currCBI.outerLocalsUsed.add(li); } else if (initCount == null || InitCount.ZERO.equals(initCount.getMin())) { // initCount will in general not be null, as the local variable // li is declared in the current class; however, if the inner // class is declared in the initializer of the local variable // declaration, then initCount could in fact be null, as we // leave the inner class before we have performed flowLocalDecl // for the local variable declaration. throw new SemanticException( "Local variable \"" + li.name() + "\" must be initialized before the class " + "declaration.", cb.position()); } } }
/** * The ast nodes will use this callback to notify us that they throw an exception of type t. This * method will throw a SemanticException if the type t is not allowed to be thrown at this point; * the exception t will be added to the throwsSet of all exception checkers in the stack, up to * (and not including) the exception checker that catches the exception. * * @param t The type of exception that the node throws. * @throws SemanticException */ public void throwsException(Type t, Position pos) throws SemanticException { if (!t.isUncheckedException()) { // go through the stack of catches and see if the exception // is caught. boolean exceptionCaught = false; ExceptionChecker ec = this; while (!exceptionCaught && ec != null) { if (ec.catchable != null) { for (Iterator<Type> iter = ec.catchable.iterator(); iter.hasNext(); ) { Type catchType = (Type) iter.next(); if (ts.isSubtype(t, catchType, ts.emptyContext())) { exceptionCaught = true; break; } } } if (!exceptionCaught && ec.throwsSet != null) { // add t to ec's throwsSet. ec.throwsSet.add(t); } if (ec.catchAllThrowable) { // stop the propagation exceptionCaught = true; } ec = ec.pop(); } if (!exceptionCaught) { reportUncaughtException(t, pos); } } }
protected void setupClassBody(ClassBody n) throws SemanticException { ClassBodyInfo newCDI = new ClassBodyInfo(); newCDI.outer = currCBI; currCBI = newCDI; // set up currClassFinalFieldInitCounts to contain mappings // for all the final fields of the class. Iterator classMembers = n.members().iterator(); while (classMembers.hasNext()) { ClassMember cm = (ClassMember) classMembers.next(); if (cm instanceof FieldDecl) { FieldDecl fd = (FieldDecl) cm; if (fd.flags().isFinal()) { MinMaxInitCount initCount; if (fd.init() != null) { // the field has an initializer initCount = new MinMaxInitCount(InitCount.ONE, InitCount.ONE); // do dataflow over the initialization expression // to pick up any uses of outer local variables. if (currCBI.outer != null) dataflow(fd.init()); } else { // the field does not have an initializer initCount = new MinMaxInitCount(InitCount.ZERO, InitCount.ZERO); } newCDI.currClassFinalFieldInitCounts.put(fd.fieldInstance(), initCount); } } } }
public boolean comprisedOfIntersectionType(IntersectionType iType) { for (Iterator it = typeArguments().iterator(); it.hasNext(); ) { Type next = (Type) it.next(); if (next instanceof IntersectionType && ts.equals(next, iType)) return true; if (next instanceof ParameterizedType && ((ParameterizedType) next).comprisedOfIntersectionType(iType)) return true; } return false; }
public String toString() { StringBuffer sb = new StringBuffer(baseType.toString()); sb.append("<"); for (Iterator it = typeArguments().iterator(); it.hasNext(); ) { sb.append(((Type) it.next())); if (it.hasNext()) { sb.append(", "); } } sb.append(">"); return sb.toString(); }
public String signature() { StringBuffer signature = new StringBuffer(); // no trailing ; for base type before the type args signature.append("L" + ((Named) baseType).fullName().replaceAll("\\.", "/") + "<"); for (Iterator it = typeArguments.iterator(); it.hasNext(); ) { SignatureType next = (SignatureType) it.next(); signature.append(next.signature()); if (it.hasNext()) { signature.append(","); } } signature.append(">;"); return signature.toString(); }
/** * Insert the list of <code>newPasses</code> into <code>passes</code> immediately after the pass * named <code>id</code>. */ public void afterPass(List passes, Pass.ID id, List newPasses) { for (ListIterator i = passes.listIterator(); i.hasNext(); ) { Pass p = (Pass) i.next(); if (p.id() == id) { for (Iterator j = newPasses.iterator(); j.hasNext(); ) { i.add(j.next()); } return; } } throw new InternalCompilerError("Pass " + id + " not found."); }
/** * Check that each static final field is initialized exactly once. * * @param cb The ClassBody of the class declaring the fields to check. * @throws SemanticException */ protected void checkStaticFinalFieldsInit(ClassBody cb) throws SemanticException { // check that all static fields have been initialized exactly once. for (Iterator iter = currCBI.currClassFinalFieldInitCounts.entrySet().iterator(); iter.hasNext(); ) { Map.Entry e = (Map.Entry) iter.next(); if (e.getKey() instanceof FieldInstance) { FieldInstance fi = (FieldInstance) e.getKey(); if (fi.flags().isStatic() && fi.flags().isFinal()) { MinMaxInitCount initCount = (MinMaxInitCount) e.getValue(); if (InitCount.ZERO.equals(initCount.getMin())) { throw new SemanticException( "field \"" + fi.name() + "\" might not have been initialized", cb.position()); } } } } }
/** * Insert the list of <code>newPasses</code> into <code>passes</code> immediately before the pass * named <code>id</code>. */ public void beforePass(List passes, Pass.ID id, List newPasses) { for (ListIterator i = passes.listIterator(); i.hasNext(); ) { Pass p = (Pass) i.next(); if (p.id() == id) { // Backup one position. i.previous(); for (Iterator j = newPasses.iterator(); j.hasNext(); ) { i.add(j.next()); } return; } } throw new InternalCompilerError("Pass " + id + " not found."); }
/** Perform necessary actions upon seeing the ConstructorDecl <code>cd</code>. */ protected void finishConstructorDecl( FlowGraph graph, ConstructorDecl cd, DataFlowItem dfIn, DataFlowItem dfOut) { ConstructorInstance ci = cd.constructorInstance(); // we need to set currCBI.fieldsConstructorInitializes correctly. // It is meant to contain the non-static final fields that the // constructor ci initializes. // // Note that dfOut.initStatus contains only the MinMaxInitCounts // for _normal_ termination of the constructor (see the // method confluence). This means that if dfOut says the min // count of the initialization for a final non-static field // is one, and that is different from what is recoreded in // currCBI.currClassFinalFieldInitCounts (which is the counts // of the initializations performed by initializers), then // the constructor does indeed initialize the field. Set s = new HashSet(); // go through every final non-static field in dfOut.initStatus Iterator iter = dfOut.initStatus.entrySet().iterator(); while (iter.hasNext()) { Entry e = (Entry) iter.next(); if (e.getKey() instanceof FieldInstance && ((FieldInstance) e.getKey()).flags().isFinal() && !((FieldInstance) e.getKey()).flags().isStatic()) { // we have a final non-static field FieldInstance fi = (FieldInstance) e.getKey(); MinMaxInitCount initCount = (MinMaxInitCount) e.getValue(); MinMaxInitCount origInitCount = (MinMaxInitCount) currCBI.currClassFinalFieldInitCounts.get(fi); if (initCount.getMin() == InitCount.ONE && (origInitCount == null || origInitCount.getMin() == InitCount.ZERO)) { // the constructor initialized this field s.add(fi); } } } if (!s.isEmpty()) { currCBI.fieldsConstructorInitializes.put(ci, s); } }
public Type convertToInferred(List typeVars, List inferredTypes) { List newBounds = new ArrayList(); for (Iterator it = typeArguments().iterator(); it.hasNext(); ) { Type next = (Type) it.next(); if (next instanceof IntersectionType) { newBounds.add(inferredTypes.get(typeVars.indexOf(next))); } else if (next instanceof ParameterizedType) { newBounds.add(((ParameterizedType) next).convertToInferred(typeVars, inferredTypes)); } /*else if (next instanceof AnySubType){ newBounds.add(((AnySubType)next).convertToInferred(typeVars, inferredTypes)); }*/ else { newBounds.add(next); } } ParameterizedType converted = ((JL5TypeSystem) typeSystem()).parameterizedType(this.baseType()); converted.typeArguments(newBounds); return converted; }
/** Perform necessary actions upon seeing the Initializer <code>initializer</code>. */ protected void finishInitializer( FlowGraph graph, Initializer initializer, DataFlowItem dfIn, DataFlowItem dfOut) { // We are finishing the checking of an intializer. // We need to copy back the init counts of any fields back into // currClassFinalFieldInitCounts, so that the counts are // correct for the next initializer or constructor. Iterator iter = dfOut.initStatus.entrySet().iterator(); while (iter.hasNext()) { Map.Entry e = (Map.Entry) iter.next(); if (e.getKey() instanceof FieldInstance) { FieldInstance fi = (FieldInstance) e.getKey(); if (fi.flags().isFinal()) { // we don't need to join the init counts, as all // dataflows will go through all of the // initializers currCBI.currClassFinalFieldInitCounts.put(fi, e.getValue()); } } } }
/** * Replace the pass named <code>id</code> in <code>passes</code> with the list of <code>newPasses * </code>. */ public void replacePass(List passes, Pass.ID id, List newPasses) { for (ListIterator i = passes.listIterator(); i.hasNext(); ) { Pass p = (Pass) i.next(); if (p.id() == id) { if (p instanceof BarrierPass) { throw new InternalCompilerError("Cannot replace a barrier pass."); } i.remove(); for (Iterator j = newPasses.iterator(); j.hasNext(); ) { i.add(j.next()); } return; } } throw new InternalCompilerError("Pass " + id + " not found."); }
/** * The confluence operator is essentially the union of all of the inItems. However, if two or more * of the initCount maps from the inItems each have a MinMaxInitCounts entry for the same * VarInstance, the conflict must be resolved, by using the minimum of all mins and the maximum of * all maxs. */ public Item confluence(List inItems, Term node, FlowGraph graph) { // Resolve any conflicts pairwise. Iterator iter = inItems.iterator(); Map m = null; while (iter.hasNext()) { Item itm = (Item) iter.next(); if (itm == BOTTOM) continue; if (m == null) { m = new HashMap(((DataFlowItem) itm).initStatus); } else { Map n = ((DataFlowItem) itm).initStatus; for (Iterator iter2 = n.entrySet().iterator(); iter2.hasNext(); ) { Map.Entry entry = (Map.Entry) iter2.next(); VarInstance v = (VarInstance) entry.getKey(); MinMaxInitCount initCount1 = (MinMaxInitCount) m.get(v); MinMaxInitCount initCount2 = (MinMaxInitCount) entry.getValue(); m.put(v, MinMaxInitCount.join(initCount1, initCount2)); } } } if (m == null) return BOTTOM; return new DataFlowItem(m); }
/** * Postpone the checking of constructors until the end of the class declaration is encountered, to * ensure that all initializers are processed first. * * <p>Also, at the end of the class declaration, check that all static final fields have been * initialized at least once, and that for each constructor all non-static final fields must have * been initialized at least once, taking into account the constructor calls. */ public Node leaveCall(Node n) throws SemanticException { if (n instanceof ConstructorDecl) { // postpone the checking of the constructors until all the // initializer blocks have been processed. currCBI.allConstructors.add(n); return n; } if (n instanceof ClassBody) { // Now that we are at the end of the class declaration, and can // be sure that all of the initializer blocks have been processed, // we can now process the constructors. for (Iterator iter = currCBI.allConstructors.iterator(); iter.hasNext(); ) { ConstructorDecl cd = (ConstructorDecl) iter.next(); // rely on the fact that our dataflow does not change the AST, // so we can discard the result of this call. dataflow(cd); } // check that all static fields have been initialized exactly once checkStaticFinalFieldsInit((ClassBody) n); // check that at the end of each constructor all non-static final // fields are initialzed. checkNonStaticFinalFieldsInit((ClassBody) n); // copy the locals used to the outer scope if (currCBI.outer != null) { currCBI.outer.localsUsedInClassBodies.put(n, currCBI.outerLocalsUsed); } // pop the stack currCBI = currCBI.outer; } return super.leaveCall(n); }
/** Type check the statement. */ public Node typeCheck(TypeChecker tc) throws SemanticException { TypeSystem ts = tc.typeSystem(); // Check that all initializers have the same type. // This should be enforced by the parser, but check again here, // just to be sure. Type t = null; for (Iterator i = inits.iterator(); i.hasNext(); ) { ForInit s = (ForInit) i.next(); if (s instanceof LocalDecl) { LocalDecl d = (LocalDecl) s; Type dt = d.type().type(); if (t == null) { t = dt; } else if (!t.equals(dt)) { throw new InternalCompilerError( "Local variable " + "declarations in a for loop initializer must all " + "be the same type, in this case " + t + ", not " + dt + ".", d.position()); } } } if (cond != null && !ts.isImplicitCastValid(cond.type(), ts.Boolean())) { throw new SemanticException( "The condition of a for statement must have boolean type.", cond.position()); } return this; }
/** Write the statement to an output file. */ public void prettyPrint(CodeWriter w, PrettyPrinter tr) { w.write("for ("); w.begin(0); if (inits != null) { boolean first = true; for (Iterator i = inits.iterator(); i.hasNext(); ) { ForInit s = (ForInit) i.next(); printForInit(s, w, tr, first); first = false; if (i.hasNext()) { w.write(","); w.allowBreak(2, " "); } } } w.write(";"); w.allowBreak(0); if (cond != null) { printBlock(cond, w, tr); } w.write(";"); w.allowBreak(0); if (iters != null) { for (Iterator i = iters.iterator(); i.hasNext(); ) { ForUpdate s = (ForUpdate) i.next(); printForUpdate(s, w, tr); if (i.hasNext()) { w.write(","); w.allowBreak(2, " "); } } } w.end(); w.write(")"); printSubStmt(body, w, tr); }
/** * Get the sub-list of passes for the job between passes <code>begin</code> and <code>end</code>, * inclusive. */ public List passes(Job job, Pass.ID begin, Pass.ID end) { List l = passes(job); Pass p = null; Iterator i = l.iterator(); while (i.hasNext()) { p = (Pass) i.next(); if (begin == p.id()) break; if (!(p instanceof BarrierPass)) i.remove(); } while (p.id() != end && i.hasNext()) { p = (Pass) i.next(); } while (i.hasNext()) { p = (Pass) i.next(); i.remove(); } return l; }
/** * Check that each non static final field has been initialized exactly once, taking into account * the fact that constructors may call other constructors. * * @param cb The ClassBody of the class declaring the fields to check. * @throws SemanticException */ protected void checkNonStaticFinalFieldsInit(ClassBody cb) throws SemanticException { // for each non-static final field instance, check that all // constructors intialize it exactly once, taking into account constructor calls. for (Iterator iter = currCBI.currClassFinalFieldInitCounts.keySet().iterator(); iter.hasNext(); ) { FieldInstance fi = (FieldInstance) iter.next(); if (fi.flags().isFinal() && !fi.flags().isStatic()) { // the field is final and not static // it must be initialized exactly once. // navigate up through all of the the constructors // that this constructor calls. boolean fieldInitializedBeforeConstructors = false; MinMaxInitCount ic = (MinMaxInitCount) currCBI.currClassFinalFieldInitCounts.get(fi); if (ic != null && !InitCount.ZERO.equals(ic.getMin())) { fieldInitializedBeforeConstructors = true; } for (Iterator iter2 = currCBI.allConstructors.iterator(); iter2.hasNext(); ) { ConstructorDecl cd = (ConstructorDecl) iter2.next(); ConstructorInstance ciStart = cd.constructorInstance(); ConstructorInstance ci = ciStart; boolean isInitialized = fieldInitializedBeforeConstructors; while (ci != null) { Set s = (Set) currCBI.fieldsConstructorInitializes.get(ci); if (s != null && s.contains(fi)) { if (isInitialized) { throw new SemanticException( "field \"" + fi.name() + "\" might have already been initialized", cd.position()); } isInitialized = true; } ci = (ConstructorInstance) currCBI.constructorCalls.get(ci); } if (!isInitialized) { throw new SemanticException( "field \"" + fi.name() + "\" might not have been initialized", ciStart.position()); } } } } }
/** * Before running <code>Pass pass</code> on <code>SourceJob job</code> make sure that all * appropriate scheduling invariants are satisfied, to ensure that all passes of other jobs that * <code>job</code> depends on will have already been done. */ protected void enforceInvariants(Job job, Pass pass) throws CyclicDependencyException { SourceJob srcJob = job.sourceJob(); if (srcJob == null) { return; } BarrierPass lastBarrier = srcJob.lastBarrier(); if (lastBarrier != null) { // make sure that _all_ dependent jobs have completed at least up to // the last barrier (not just children). // // Ideally the invariant should be that only the source jobs that // job _depends on_ should be brought up to the last barrier. // This is work to be done in the future... List allDependentSrcs = new ArrayList(srcJob.dependencies()); Iterator i = allDependentSrcs.iterator(); while (i.hasNext()) { Source s = (Source) i.next(); Object o = jobs.get(s); if (o == COMPLETED_JOB) continue; if (o == null) { throw new InternalCompilerError("Unknown source " + s); } SourceJob sj = (SourceJob) o; if (sj.pending(lastBarrier.id())) { // Make the job run up to the last barrier. // We ignore the return result, since even if the job // fails, we will keep on going and see // how far we get... if (Report.should_report(Report.frontend, 3)) { Report.report(3, "Running " + sj + " to " + lastBarrier.id() + " for " + srcJob); } runToPass(sj, lastBarrier.id()); } } } if (pass instanceof GlobalBarrierPass) { // need to make sure that _all_ jobs have completed just up to // this global barrier. // If we hit a cyclic dependency, ignore it and run the other // jobs up to that pass. Then try again to run the cyclic // pass. If we hit the cycle again for the same job, stop. LinkedList barrierWorklist = new LinkedList(jobs.values()); while (!barrierWorklist.isEmpty()) { Object o = barrierWorklist.removeFirst(); if (o == COMPLETED_JOB) continue; SourceJob sj = (SourceJob) o; if (sj.completed(pass.id()) || sj.nextPass() == sj.passByID(pass.id())) { // the source job has either done this global pass // (which is possible if the job was loaded late in the // game), or is right up to the global barrier. continue; } // Make the job run up to just before the global barrier. // We ignore the return result, since even if the job // fails, we will keep on going and see // how far we get... Pass beforeGlobal = sj.getPreviousTo(pass.id()); if (Report.should_report(Report.frontend, 3)) { Report.report(3, "Running " + sj + " to " + beforeGlobal.id() + " for " + srcJob); } // Don't use runToPass, since that catches the // CyclicDependencyException that we should report // back to the caller. while (!sj.pendingPasses().isEmpty()) { Pass p = (Pass) sj.pendingPasses().get(0); runPass(sj, p); if (p == beforeGlobal) { break; } } } } }