private boolean blockEndsInBreakReturnThrow(Tree.Block that) {
int size = that.getStatements().size();
if (size > 0) {
Tree.Statement s = that.getStatements().get(size - 1);
return s instanceof Tree.Break || s instanceof Tree.Return || s instanceof Tree.Throw;
} else {
return false;
}
}
static void attributeArgument(final Tree.AttributeArgument that, final GenerateJsVisitor gen) {
gen.out("(function()");
gen.beginBlock();
if (gen.opts.isVerbose() && that.getParameter() != null) {
gen.out("//AttributeArgument ", that.getParameter().getName());
gen.location(that);
gen.endLine();
}
Tree.Block block = that.getBlock();
Tree.SpecifierExpression specExpr = that.getSpecifierExpression();
if (specExpr != null) {
gen.out("return ");
if (!gen.isNaturalLiteral(specExpr.getExpression().getTerm())) {
gen.visitSingleExpression(specExpr.getExpression());
}
} else if (block != null) {
gen.visitStatements(block.getStatements());
}
gen.endBlock();
gen.out("())");
}
@Override
public void visit(Tree.WhileStatement that) {
Tree.WhileClause whileClause = that.getWhileClause();
Tree.ConditionList conditionList = whileClause.getConditionList();
Tree.ConditionList cl = conditionList;
if (cl != null) {
cl.visit(this);
}
boolean d = beginDeclarationScope();
SpecificationState as = beginSpecificationScope();
Tree.Block block = whileClause.getBlock();
if (block != null) {
if (isVariable() || isLate()) {
block.visit(this);
} else {
boolean c = inLoop;
inLoop = true;
block.visit(this);
inLoop = c;
}
}
boolean possiblyAssignedByWhileClause = specified.possibly;
boolean definitelyAssignedByWhileClause = specified.definitely;
endDeclarationScope(d);
endSpecificationScope(as);
specified.definitely =
specified.definitely
|| (definitelyAssignedByWhileClause && isAlwaysSatisfied(conditionList));
specified.possibly =
specified.possibly || (possiblyAssignedByWhileClause && !isNeverSatisfied(conditionList));
checkDeclarationSection(that);
}
@Override
public void visit(Tree.Block that) {
Scope scope = that.getScope();
if (scope instanceof Constructor) {
if (definitelyInitedBy.contains(delegatedConstructor)) {
specified.definitely = true;
}
if (possiblyInitedBy.contains(delegatedConstructor)) {
specified.possibly = true;
}
delegatedConstructor = null;
}
boolean oe = endsInBreakReturnThrow;
Tree.Continue olc = lastContinue;
Tree.Statement olcs = lastContinueStatement;
// rather nasty way of detecting that the continue
// occurs in another conditional branch of the
// statement containing this block, even though we
// did not find it in _this_ branch
boolean continueInSomeBranchOfCurrentConditional =
lastContinue != null && lastContinueStatement == null;
boolean blockEndsInBreakReturnThrow = blockEndsInBreakReturnThrow(that);
endsInBreakReturnThrow = endsInBreakReturnThrow || blockEndsInBreakReturnThrow;
Tree.Continue last = null;
Tree.Statement lastStatement = null;
for (Tree.Statement st : that.getStatements()) {
ContinueVisitor cv = new ContinueVisitor(olc);
st.visit(cv);
if (cv.node != null) {
last = cv.node;
lastStatement = st;
}
if (cv.found) {
olc = null;
olcs = null;
}
}
if (blockEndsInBreakReturnThrow || continueInSomeBranchOfCurrentConditional) {
lastContinue = last;
lastContinueStatement = lastStatement;
}
super.visit(that);
endsInBreakReturnThrow = oe;
lastContinue = olc;
lastContinueStatement = olcs;
if (scope instanceof Constructor) {
Constructor c = (Constructor) scope;
if (specified.definitely) {
definitelyInitedBy.add(c);
}
if (specified.possibly) {
possiblyInitedBy.add(c);
}
}
if (isNonPartialConstructor(scope) && declaration.getContainer() == scope.getContainer()) {
if (!specified.definitely) {
initedByEveryConstructor = false;
}
}
}
@Override
public void visit(Tree.IfStatement that) {
if (that == lastContinueStatement) {
lastContinueStatement = null;
}
Tree.IfClause ifClause = that.getIfClause();
Tree.ConditionList conditionList = ifClause.getConditionList();
if (ifClause != null) {
Tree.ConditionList cl = conditionList;
if (cl != null) {
cl.visit(this);
}
}
boolean d = beginDeclarationScope();
SpecificationState as = beginSpecificationScope();
if (ifClause != null) {
Tree.Block block = ifClause.getBlock();
if (block != null) {
block.visit(this);
}
}
boolean definitelyAssignedByIfClause = specified.definitely || specified.exited;
boolean possiblyAssignedByIfClause = specified.possibly;
boolean possiblyExitedFromIfClause = specified.exited;
boolean specifiedByExitsFromIfClause = specified.byExits;
endDeclarationScope(d);
endSpecificationScope(as);
boolean definitelyAssignedByElseClause;
boolean possiblyAssignedByElseClause;
boolean possiblyExitedFromElseClause;
boolean specifiedByExitsFromElseClause;
Tree.ElseClause elseClause = that.getElseClause();
if (elseClause != null) {
d = beginDeclarationScope();
as = beginSpecificationScope();
elseClause.visit(this);
definitelyAssignedByElseClause = specified.definitely || specified.exited;
possiblyAssignedByElseClause = specified.possibly;
possiblyExitedFromElseClause = specified.exited;
specifiedByExitsFromElseClause = specified.byExits;
endDeclarationScope(d);
endSpecificationScope(as);
} else {
definitelyAssignedByElseClause = false;
possiblyAssignedByElseClause = false;
possiblyExitedFromElseClause = false;
specifiedByExitsFromElseClause = true;
}
if (isAlwaysSatisfied(conditionList)) {
specified.definitely = specified.definitely || definitelyAssignedByIfClause;
specified.possibly = specified.possibly || possiblyAssignedByIfClause;
specified.exited = specified.exited || possiblyExitedFromIfClause;
specified.byExits = specified.byExits && specifiedByExitsFromIfClause;
} else if (isNeverSatisfied(conditionList)) {
specified.definitely = specified.definitely || definitelyAssignedByElseClause;
specified.possibly = specified.possibly || possiblyAssignedByElseClause;
specified.exited = specified.exited || possiblyExitedFromElseClause;
specified.byExits = specified.byExits && specifiedByExitsFromElseClause;
} else {
specified.definitely =
specified.definitely || definitelyAssignedByIfClause && definitelyAssignedByElseClause;
specified.possibly =
specified.possibly || possiblyAssignedByIfClause || possiblyAssignedByElseClause;
specified.exited =
specified.exited || possiblyExitedFromIfClause || possiblyExitedFromElseClause;
specified.byExits =
specified.byExits && specifiedByExitsFromIfClause && specifiedByExitsFromElseClause;
}
checkDeclarationSection(that);
}