use of com.sun.tools.javac.tree.JCTree in project ceylon-compiler by ceylon.
the class ExpressionTransformer method makeOptimizedInCharacterRange.
protected JCTree makeOptimizedInCharacterRange(Tree.InOp op) {
com.sun.tools.javac.code.Type type = syms().intType;
com.sun.tools.javac.code.Type ceylonType = syms().ceylonCharacterType;
// x in y..z with x, y, z all Character
Tree.RangeOp rangeOp = (Tree.RangeOp) op.getRightTerm();
JCExpression x = transformExpression(op.getLeftTerm(), BoxingStrategy.UNBOXED, typeFact().getObjectType());
JCExpression first = transformExpression(rangeOp.getLeftTerm(), BoxingStrategy.UNBOXED, rangeOp.getLeftTerm().getTypeModel());
JCExpression last = transformExpression(rangeOp.getRightTerm(), BoxingStrategy.UNBOXED, rangeOp.getRightTerm().getTypeModel());
SyntheticName xName = naming.temp("x");
SyntheticName firstName = naming.temp("first");
SyntheticName lastName = naming.temp("last");
SyntheticName recursiveName = naming.temp("recursive");
return make().LetExpr(List.<JCStatement>of(makeVar(xName, make().Type(type), x), makeVar(firstName, make().Type(type), first), makeVar(lastName, make().Type(type), last), // so we have to replicate that **short-circuit** logic here
makeVar(recursiveName, make().Type(syms().booleanType), make().Binary(JCTree.AND, make().Binary(JCTree.GT, firstName.makeIdent(), make().Apply(null, naming.makeSelect(make().QualIdent(ceylonType.tsym), "getSuccessor"), List.<JCExpression>of(firstName.makeIdent()))), make().Binary(JCTree.GT, make().Apply(null, naming.makeSelect(make().QualIdent(ceylonType.tsym), "getPredecessor"), List.<JCExpression>of(lastName.makeIdent())), lastName.makeIdent())))), make().Conditional(make().Binary(JCTree.LT, firstName.makeIdent(), lastName.makeIdent()), make().Binary(JCTree.AND, make().Binary(JCTree.LE, xName.makeIdent(), lastName.makeIdent()), make().Binary(JCTree.GE, xName.makeIdent(), firstName.makeIdent())), make().Binary(JCTree.AND, make().Binary(JCTree.GE, xName.makeIdent(), lastName.makeIdent()), make().Binary(JCTree.LE, xName.makeIdent(), firstName.makeIdent()))));
}
use of com.sun.tools.javac.tree.JCTree in project ceylon-compiler by ceylon.
the class ExpressionTransformer method transformSpreadOperator.
private JCExpression transformSpreadOperator(final Tree.QualifiedMemberOrTypeExpression expr, TermTransformer transformer) {
at(expr);
boolean spreadMethodReferenceOuter = !expr.equals(this.spreading) && !isWithinInvocation() && isCeylonCallableSubtype(expr.getTypeModel());
boolean spreadMethodReferenceInner = expr.equals(this.spreading) && isWithinInvocation();
Tree.QualifiedMemberOrTypeExpression oldSpreading = spreading;
if (spreadMethodReferenceOuter) {
spreading = expr;
}
try {
Naming.SyntheticName varBaseName = naming.alias("spread");
ListBuffer<JCStatement> letStmts = ListBuffer.<JCStatement>lb();
final Naming.SyntheticName srcIterableName;
if (spreadMethodReferenceInner) {
// use the var we initialized in the outer
srcIterableName = this.memberPrimary;
} else {
srcIterableName = varBaseName.suffixedBy(Suffix.$iterable$);
}
if (spreadMethodReferenceOuter) {
// if we're in the outer, note then name of the var for use in the inner.
this.memberPrimary = srcIterableName;
}
Naming.SyntheticName srcIteratorName = varBaseName.suffixedBy(Suffix.$iterator$);
Type srcElementType = expr.getTarget().getQualifyingType();
JCExpression srcIterableTypeExpr = makeJavaType(typeFact().getIterableType(srcElementType), JT_NO_PRIMITIVES);
JCExpression srcIterableExpr;
boolean isSuperOrSuperOf = false;
if (spreadMethodReferenceInner) {
srcIterableExpr = srcIterableName.makeIdent();
} else {
boolean isSuper = isSuper(expr.getPrimary());
isSuperOrSuperOf = isSuper || isSuperOf(expr.getPrimary());
if (isSuperOrSuperOf) {
// so we just refer to it later
if (isSuper) {
Declaration member = expr.getPrimary().getTypeModel().getDeclaration().getMember("iterator", null, false);
srcIterableExpr = transformSuper(expr, (TypeDeclaration) member.getContainer());
} else
srcIterableExpr = transformSuperOf(expr, expr.getPrimary(), "iterator");
} else {
srcIterableExpr = transformExpression(expr.getPrimary(), BoxingStrategy.BOXED, typeFact().getIterableType(srcElementType));
}
}
// do not capture the iterable for super invocations: see above
if (!spreadMethodReferenceInner && !isSuperOrSuperOf) {
JCVariableDecl srcIterable = null;
srcIterable = makeVar(Flags.FINAL, srcIterableName, srcIterableTypeExpr, srcIterableExpr);
letStmts.prepend(srcIterable);
}
Type resultElementType = expr.getTarget().getType();
Type resultAbsentType = typeFact().getIteratedAbsentType(expr.getPrimary().getTypeModel());
// private Iterator<srcElementType> iterator = srcIterableName.iterator();
JCVariableDecl srcIterator = makeVar(Flags.FINAL, srcIteratorName, makeJavaType(typeFact().getIteratorType(srcElementType)), make().Apply(null, // for super we do not capture it because we can't and it's constant anyways
naming.makeQualIdent(isSuperOrSuperOf ? srcIterableExpr : srcIterableName.makeIdent(), "iterator"), List.<JCExpression>nil()));
Naming.SyntheticName iteratorResultName = varBaseName.suffixedBy(Suffix.$element$);
/* public Object next() {
* Object result;
* if (!((result = iterator.next()) instanceof Finished)) {
* result = transformedMember(result);
* }
* return result;
*/
/* Any arguments in the member of the spread would get re-evaluated on each iteration
* so we need to shift them to the scope of the Let to ensure they're evaluated once.
*/
boolean aliasArguments = (transformer instanceof InvocationTermTransformer) && ((InvocationTermTransformer) transformer).invocation.getNode() instanceof Tree.InvocationExpression && ((Tree.InvocationExpression) ((InvocationTermTransformer) transformer).invocation.getNode()).getPositionalArgumentList() != null;
if (aliasArguments) {
((InvocationTermTransformer) transformer).callBuilder.argumentHandling(CallBuilder.CB_ALIAS_ARGS, varBaseName);
}
JCNewClass iterableClass;
boolean prevSyntheticClassBody = expressionGen().withinSyntheticClassBody(true);
try {
JCExpression transformedElement = applyErasureAndBoxing(iteratorResultName.makeIdent(), typeFact().getAnythingType(), CodegenUtil.hasTypeErased(expr.getPrimary()), true, BoxingStrategy.BOXED, srcElementType, 0);
transformedElement = transformMemberExpression(expr, transformedElement, transformer);
// be handled by the previous recursion
if (spreadMethodReferenceOuter) {
return make().LetExpr(letStmts.toList(), transformedElement);
}
transformedElement = applyErasureAndBoxing(transformedElement, resultElementType, // not necessarily of the applied member
expr.getTarget().getDeclaration() instanceof TypedDeclaration ? CodegenUtil.hasTypeErased((TypedDeclaration) expr.getTarget().getDeclaration()) : false, !CodegenUtil.isUnBoxed(expr), BoxingStrategy.BOXED, resultElementType, 0);
MethodDefinitionBuilder nextMdb = MethodDefinitionBuilder.systemMethod(this, "next");
nextMdb.isOverride(true);
nextMdb.annotationFlags(Annotations.IGNORE);
nextMdb.modifiers(Flags.PUBLIC | Flags.FINAL);
nextMdb.resultType(null, make().Type(syms().objectType));
nextMdb.body(List.of(makeVar(iteratorResultName, make().Type(syms().objectType), null), make().If(make().Unary(JCTree.NOT, make().TypeTest(make().Assign(iteratorResultName.makeIdent(), make().Apply(null, naming.makeQualIdent(srcIteratorName.makeIdent(), "next"), List.<JCExpression>nil())), make().Type(syms().ceylonFinishedType))), make().Block(0, List.<JCStatement>of(make().Exec(make().Assign(iteratorResultName.makeIdent(), transformedElement)))), null), make().Return(iteratorResultName.makeIdent())));
JCMethodDecl nextMethod = nextMdb.build();
// new AbstractIterator()
JCNewClass iteratorClass = make().NewClass(null, null, make().TypeApply(make().QualIdent(syms().ceylonAbstractIteratorType.tsym), List.of(makeJavaType(resultElementType, JT_TYPE_ARGUMENT))), List.of(makeReifiedTypeArgument(resultElementType)), make().AnonymousClassDef(make().Modifiers(0), List.of(srcIterator, nextMethod)));
MethodDefinitionBuilder iteratorMdb = MethodDefinitionBuilder.systemMethod(this, "iterator");
iteratorMdb.isOverride(true);
iteratorMdb.annotationFlags(Annotations.IGNORE);
iteratorMdb.modifiers(Flags.PUBLIC | Flags.FINAL);
iteratorMdb.resultType(null, makeJavaType(typeFact().getIteratorType(resultElementType)));
iteratorMdb.body(make().Return(iteratorClass));
// new AbstractIterable()
iterableClass = make().NewClass(null, null, make().TypeApply(make().QualIdent(syms().ceylonAbstractIterableType.tsym), List.of(makeJavaType(resultElementType, JT_TYPE_ARGUMENT), makeJavaType(resultAbsentType, JT_TYPE_ARGUMENT))), List.of(makeReifiedTypeArgument(resultElementType), makeReifiedTypeArgument(resultAbsentType)), make().AnonymousClassDef(make().Modifiers(0), List.<JCTree>of(iteratorMdb.build())));
} finally {
expressionGen().withinSyntheticClassBody(prevSyntheticClassBody);
}
if (aliasArguments) {
letStmts = letStmts.appendList(((InvocationTermTransformer) transformer).callBuilder.getStatements());
}
JCMethodInvocation result = make().Apply(null, naming.makeQualIdent(iterableClass, "sequence"), List.<JCExpression>nil());
JCExpression spread = letStmts.isEmpty() ? result : make().LetExpr(letStmts.toList(), result);
// Do we *statically* know the result must be a Sequence
final boolean primaryIsSequence = typeFact().isNonemptyIterableType(expr.getPrimary().getTypeModel());
Type returnElementType = expr.getTarget().getType();
if (primaryIsSequence) {
int flags = EXPR_DOWN_CAST;
spread = applyErasureAndBoxing(spread, typeFact().getSequentialType(returnElementType), false, true, BoxingStrategy.BOXED, primaryIsSequence ? typeFact().getSequenceType(returnElementType) : typeFact().getSequentialType(returnElementType), flags);
}
return spread;
} finally {
spreading = oldSpreading;
}
}
use of com.sun.tools.javac.tree.JCTree in project ceylon-compiler by ceylon.
the class NamedArgumentInvocation method bindObjectArgument.
private void bindObjectArgument(Tree.ObjectArgument objectArg, Parameter declaredParam, Naming.SyntheticName argName) {
ListBuffer<JCStatement> statements;
List<JCTree> object = gen.classGen().transformObjectArgument(objectArg);
// No need to worry about boxing (it cannot be a boxed type)
JCVariableDecl varDecl = gen.makeLocalIdentityInstance(argName.getName(), Naming.quoteClassName(objectArg.getIdentifier().getText()), false);
statements = toStmts(objectArg, object).append(varDecl);
bind(declaredParam, argName, gen.makeJavaType(objectArg.getType().getTypeModel()), statements.toList());
}
use of com.sun.tools.javac.tree.JCTree in project ceylon-compiler by ceylon.
the class StatementTransformer method transformBlock.
public List<JCStatement> transformBlock(Tree.Block block, boolean revertRet) {
if (block == null) {
return List.<JCStatement>nil();
}
at(block);
CeylonVisitor v = gen().visitor;
final ListBuffer<JCTree> prevDefs = v.defs;
final boolean prevInInitializer = v.inInitializer;
final ClassDefinitionBuilder prevClassBuilder = v.classBuilder;
List<JCStatement> result;
try {
v.defs = new ListBuffer<JCTree>();
v.inInitializer = false;
v.classBuilder = current();
java.util.Iterator<Statement> statements = block.getStatements().iterator();
while (statements.hasNext()) {
Tree.Statement stmt = statements.next();
Transformer<JCStatement, Return> returnTransformer;
if (revertRet && stmt instanceof Tree.Declaration) {
returnTransformer = returnTransformer(defaultReturnTransformer);
} else {
returnTransformer = this.returnTransformer;
}
try {
HasErrorException error = errors().getFirstErrorBlock(stmt);
if (error == null) {
stmt.visit(v);
} else {
v.append(this.makeThrowUnresolvedCompilationError(error));
break;
}
} finally {
returnTransformer(returnTransformer);
}
}
result = (List<JCStatement>) v.getResult().toList();
} finally {
v.classBuilder = prevClassBuilder;
v.inInitializer = prevInInitializer;
v.defs = prevDefs;
// Close Substitutions which were scoped to this block
Scope scope = block.getScope();
while (scope instanceof ConditionScope) {
scope = scope.getScope();
}
naming.closeScopedSubstitutions(scope);
}
return result;
}
use of com.sun.tools.javac.tree.JCTree in project groovy-cps by cloudbees.
the class Translator method translateMethod.
/**
* @param e
* Method in {@code fqcn} to translate.
*/
private void translateMethod(final CompilationUnitTree cut, ExecutableElement e, JDefinedClass $output, String fqcn, String overloadResolved) {
String methodName = n(e);
boolean isPublic = e.getModifiers().contains(Modifier.PUBLIC);
JMethod delegating = $output.method(isPublic ? JMod.PUBLIC | JMod.STATIC : JMod.STATIC, (JType) null, methodName);
JMethod m = $output.method(JMod.PRIVATE | JMod.STATIC, (JType) null, overloadResolved);
Map<String, JTypeVar> typeVars = new HashMap<>();
e.getTypeParameters().forEach(p -> {
String name = n(p);
JTypeVar typeVar = delegating.generify(name);
JTypeVar typeVar2 = m.generify(name);
p.getBounds().forEach(b -> {
JClass binding = (JClass) t(b, typeVars);
typeVar.bound(binding);
typeVar2.bound(binding);
});
typeVars.put(name, typeVar);
});
JType type = t(e.getReturnType(), typeVars);
delegating.type(type);
m.type(type);
List<JVar> delegatingParams = new ArrayList<>();
List<JVar> params = new ArrayList<>();
e.getParameters().forEach(p -> {
JType paramType = t(p.asType(), typeVars);
delegatingParams.add(e.isVarArgs() && p == e.getParameters().get(e.getParameters().size() - 1) ? delegating.varParam(paramType.elementType(), n(p)) : delegating.param(paramType, n(p)));
params.add(m.param(paramType, n(p)));
});
e.getThrownTypes().forEach(ex -> {
delegating._throws((JClass) t(ex));
m._throws((JClass) t(ex));
});
boolean returnsVoid = e.getReturnType().getKind() == TypeKind.VOID;
if (isPublic) {
// preamble
/*
If the call to this method happen outside CPS code, execute normally via DefaultGroovyMethods
*/
delegating.body()._if(JOp.cand(JOp.not($Caller.staticInvoke("isAsynchronous").tap(inv -> {
inv.arg(delegatingParams.get(0));
inv.arg(methodName);
for (int i = 1; i < delegatingParams.size(); i++) inv.arg(delegatingParams.get(i));
})), JOp.not($Caller.staticInvoke("isAsynchronous").arg($output.dotclass()).arg(methodName).args(params))))._then().tap(blk -> {
JClass $WhateverGroovyMethods = codeModel.ref(fqcn);
JInvocation forward = $WhateverGroovyMethods.staticInvoke(methodName).args(delegatingParams);
if (returnsVoid) {
blk.add(forward);
blk._return();
} else {
blk._return(forward);
}
});
}
JInvocation delegateCall = $output.staticInvoke(overloadResolved);
if (returnsVoid) {
delegating.body().add(delegateCall);
} else {
delegating.body()._return(delegateCall);
}
delegatingParams.forEach(p -> delegateCall.arg(p));
JVar $b = m.body().decl($Builder, "b", JExpr._new($Builder).arg(JExpr.invoke("loc").arg(methodName)));
JInvocation f = JExpr._new($CpsFunction);
// parameter names
f.arg(codeModel.ref(Arrays.class).staticInvoke("asList").tap(inv -> {
e.getParameters().forEach(p -> inv.arg(n(p)));
}));
// translate the method body into an expression that invokes Builder
f.arg(trees.getTree(e).getBody().accept(new SimpleTreeVisitor<JExpression, Void>() {
private JExpression visit(Tree t) {
if (t == null)
return JExpr._null();
return visit(t, null);
}
/**
* Maps a symbol to its source location.
*/
private JExpression loc(Tree t) {
long pos = trees.getSourcePositions().getStartPosition(cut, t);
return JExpr.lit((int) cut.getLineMap().getLineNumber(pos));
}
@Override
public JExpression visitWhileLoop(WhileLoopTree wt, Void __) {
return $b.invoke("while_").arg(// TODO: label
JExpr._null()).arg(visit(wt.getCondition())).arg(visit(wt.getStatement()));
}
@Override
public JExpression visitMethodInvocation(MethodInvocationTree mt, Void __) {
ExpressionTree ms = mt.getMethodSelect();
JInvocation inv;
if (ms instanceof MemberSelectTree) {
MemberSelectTree mst = (MemberSelectTree) ms;
inv = $b.invoke("functionCall").arg(loc(mt)).arg(visit(mst.getExpression())).arg(n(mst.getIdentifier()));
} else if (ms instanceof JCIdent) {
// invocation without object selection, like foo(bar,zot)
JCIdent it = (JCIdent) ms;
if (!it.sym.owner.toString().equals(fqcn)) {
// static import
inv = $b.invoke("functionCall").arg(loc(mt)).arg($b.invoke("constant").arg(t(it.sym.owner.type).dotclass())).arg(n(it));
} else {
// invocation on this class
String overloadResolved = mangledName((Symbol.MethodSymbol) it.sym);
Optional<? extends Element> callSite = elements.getTypeElement(fqcn).getEnclosedElements().stream().filter(e -> e.getKind() == ElementKind.METHOD && mangledName((ExecutableElement) e).equals(overloadResolved)).findAny();
if (callSite.isPresent()) {
ExecutableElement e = (ExecutableElement) callSite.get();
if (e.getModifiers().contains(Modifier.PUBLIC) && !e.isVarArgs() && !e.getParameters().stream().anyMatch(p -> types.isAssignable(p.asType(), closureType))) {
// Delegate to the standard version.
inv = $b.invoke("staticCall").arg(loc(mt)).arg(t(it.sym.owner.type).dotclass()).arg(n(e));
} else if (overloadsResolved.containsKey(overloadResolved)) {
// Private, so delegate to our mangled version.
inv = $b.invoke("staticCall").arg(loc(mt)).arg($output.dotclass()).arg(overloadResolved);
} else {
throw new IllegalStateException("Not yet translating a " + e.getModifiers() + " method; translatable.txt might need to include: " + fqcn + "." + e);
}
} else {
throw new IllegalStateException("Could not find self-call site " + overloadResolved + " for " + mt);
}
}
} else {
// TODO: figure out what can come here
throw new UnsupportedOperationException(ms.toString());
}
mt.getArguments().forEach(a -> inv.arg(visit(a)));
return inv;
}
@Override
public JExpression visitVariable(VariableTree vt, Void __) {
return $b.invoke("declareVariable").arg(loc(vt)).arg(erasure(vt).dotclass()).arg(n(vt)).arg(visit(vt.getInitializer()));
}
@Override
public JExpression visitIdentifier(IdentifierTree it, Void __) {
JCIdent idt = (JCIdent) it;
return idt.sym.accept(new DefaultSymbolVisitor<JExpression, Void>() {
@Override
public JExpression visitClassSymbol(ClassSymbol cs, Void __) {
return $b.invoke("constant").arg(t(cs.asType()).dotclass());
}
@Override
public JExpression visitVarSymbol(VarSymbol s, Void __) {
return $b.invoke("localVariable").arg(n(s.name));
}
@Override
public JExpression visitSymbol(Symbol s, Void __) {
throw new UnsupportedOperationException(s.toString());
}
}, __);
}
@Override
public JExpression visitBlock(BlockTree bt, Void __) {
JInvocation inv = $b.invoke("block");
bt.getStatements().forEach(s -> inv.arg(visit(s)));
return inv;
}
@Override
public JExpression visitReturn(ReturnTree rt, Void __) {
return $b.invoke("return_").arg(visit(rt.getExpression()));
}
/**
* When used outside {@link MethodInvocationTree}, this is property access.
*/
@Override
public JExpression visitMemberSelect(MemberSelectTree mt, Void __) {
return $b.invoke("property").arg(loc(mt)).arg(visit(mt.getExpression())).arg(n(mt.getIdentifier()));
}
@Override
public JExpression visitTypeCast(TypeCastTree tt, Void __) {
return $b.invoke("cast").arg(loc(tt)).arg(visit(tt.getExpression())).arg(erasure(tt.getType()).dotclass()).arg(JExpr.lit(false));
}
@Override
public JExpression visitIf(IfTree it, Void __) {
JInvocation inv = $b.invoke("if_").arg(visit(it.getCondition())).arg(visit(it.getThenStatement()));
if (it.getElseStatement() != null)
inv.arg(visit(it.getElseStatement()));
return inv;
}
@Override
public JExpression visitNewClass(NewClassTree nt, Void __) {
// TODO: outer class
if (nt.getEnclosingExpression() != null)
throw new UnsupportedOperationException();
return $b.invoke("new_").tap(inv -> {
inv.arg(loc(nt));
inv.arg(t(((JCTree) nt).type).dotclass());
nt.getArguments().forEach(et -> inv.arg(visit(et)));
});
}
@Override
public JExpression visitExpressionStatement(ExpressionStatementTree et, Void __) {
return visit(et.getExpression());
}
@Override
public JExpression visitLiteral(LiteralTree lt, Void __) {
return $b.invoke("constant").arg(JExpr.literal(lt.getValue()));
}
@Override
public JExpression visitParenthesized(ParenthesizedTree pt, Void __) {
return visit(pt.getExpression());
}
@Override
public JExpression visitBinary(BinaryTree bt, Void __) {
return $b.invoke(opName(bt.getKind())).arg(loc(bt)).arg(visit(bt.getLeftOperand())).arg(visit(bt.getRightOperand()));
}
@Override
public JExpression visitUnary(UnaryTree ut, Void __) {
return $b.invoke(opName(ut.getKind())).arg(loc(ut)).arg(visit(ut.getExpression()));
}
@Override
public JExpression visitCompoundAssignment(CompoundAssignmentTree ct, Void __) {
return $b.invoke(opName(ct.getKind())).arg(loc(ct)).arg(visit(ct.getVariable())).arg(visit(ct.getExpression()));
}
private String opName(Kind kind) {
switch(kind) {
case EQUAL_TO:
return "compareEqual";
case NOT_EQUAL_TO:
return "compareNotEqual";
case LESS_THAN_EQUAL:
return "lessThanEqual";
case LESS_THAN:
return "lessThan";
case GREATER_THAN_EQUAL:
return "greaterThanEqual";
case GREATER_THAN:
return "greaterThan";
case PREFIX_INCREMENT:
return "prefixInc";
case POSTFIX_INCREMENT:
return "postfixInc";
case POSTFIX_DECREMENT:
return "postfixDec";
case LOGICAL_COMPLEMENT:
return "not";
case CONDITIONAL_OR:
return "logicalOr";
case CONDITIONAL_AND:
return "logicalAnd";
case PLUS:
return "plus";
case PLUS_ASSIGNMENT:
return "plusEqual";
case MINUS:
return "minus";
case MINUS_ASSIGNMENT:
return "minusEqual";
}
throw new UnsupportedOperationException(kind.toString());
}
@Override
public JExpression visitAssignment(AssignmentTree at, Void __) {
return $b.invoke("assign").arg(loc(at)).arg(visit(at.getVariable())).arg(visit(at.getExpression()));
}
@Override
public JExpression visitNewArray(NewArrayTree nt, Void __) {
if (nt.getInitializers() != null) {
return $b.invoke("newArrayFromInitializers").tap(inv -> {
nt.getInitializers().forEach(d -> inv.arg(visit(d)));
});
} else {
return $b.invoke("newArray").tap(inv -> {
inv.arg(loc(nt));
inv.arg(t(nt.getType()).dotclass());
nt.getDimensions().forEach(d -> inv.arg(visit(d)));
});
}
}
@Override
public JExpression visitForLoop(ForLoopTree ft, Void __) {
return $b.invoke("forLoop").arg(JExpr._null()).arg($b.invoke("sequence").tap(inv -> ft.getInitializer().forEach(i -> inv.arg(visit(i))))).arg(visit(ft.getCondition())).arg($b.invoke("sequence").tap(inv -> ft.getUpdate().forEach(i -> inv.arg(visit(i))))).arg(visit(ft.getStatement()));
}
@Override
public JExpression visitEnhancedForLoop(EnhancedForLoopTree et, Void __) {
return $b.invoke("forInLoop").arg(loc(et)).arg(JExpr._null()).arg(erasure(et.getVariable()).dotclass()).arg(n(et.getVariable())).arg(visit(et.getExpression())).arg(visit(et.getStatement()));
}
@Override
public JExpression visitArrayAccess(ArrayAccessTree at, Void __) {
return $b.invoke("array").arg(loc(at)).arg(visit(at.getExpression())).arg(visit(at.getIndex()));
}
@Override
public JExpression visitBreak(BreakTree node, Void __) {
if (node.getLabel() != null)
throw new UnsupportedOperationException();
return $b.invoke("break_").arg(JExpr._null());
}
@Override
public JExpression visitContinue(ContinueTree node, Void aVoid) {
if (node.getLabel() != null)
throw new UnsupportedOperationException();
return $b.invoke("continue_").arg(JExpr._null());
}
@Override
public JExpression visitInstanceOf(InstanceOfTree it, Void __) {
return $b.invoke("instanceOf").arg(loc(it)).arg(visit(it.getExpression())).arg($b.invoke("constant").arg(t(it.getType()).dotclass()));
}
@Override
public JExpression visitThrow(ThrowTree tt, Void __) {
return $b.invoke("throw_").arg(loc(tt)).arg(visit(tt.getExpression()));
}
@Override
public JExpression visitDoWhileLoop(DoWhileLoopTree dt, Void __) {
return $b.invoke("doWhile").arg(JExpr._null()).arg(visit(dt.getStatement())).arg(visit(dt.getCondition()));
}
@Override
public JExpression visitConditionalExpression(ConditionalExpressionTree ct, Void __) {
return $b.invoke("ternaryOp").arg(visit(ct.getCondition())).arg(visit(ct.getTrueExpression())).arg(visit(ct.getFalseExpression()));
}
@Override
public JExpression visitTry(TryTree tt, Void __) {
return $b.invoke("tryCatch").arg(visit(tt.getBlock())).arg(visit(tt.getFinallyBlock())).tap(inv -> tt.getCatches().forEach(ct -> JExpr._new($CatchExpression).arg(t(ct.getParameter()).dotclass()).arg(n(ct.getParameter())).arg(visit(ct.getBlock()))));
}
@Override
protected JExpression defaultAction(Tree node, Void aVoid) {
throw new UnsupportedOperationException(node.toString());
}
}, null));
JVar $f = m.body().decl($CpsFunction, "f", f);
m.body()._throw(JExpr._new($CpsCallableInvocation).arg($f).arg(JExpr._null()).args(params));
}
Aggregations