@Override protected void appendCatchClauseParameter(XCatchClause catchClause, JvmTypeReference parameterType, String parameterName, ITreeAppendable appendable) { appendExtensionAnnotation(catchClause.getDeclaredParam(), catchClause, appendable, false); super.appendCatchClauseParameter(catchClause, parameterType, parameterName, appendable); }
@Override protected void appendClosureParameter(JvmFormalParameter closureParam, LightweightTypeReference parameterType, ITreeAppendable appendable) { appendExtensionAnnotation(closureParam, closureParam, appendable, false); super.appendClosureParameter(closureParam, parameterType, appendable); }
@Override protected void appendForLoopParameter(XForLoopExpression expr, ITreeAppendable appendable) { appendExtensionAnnotation(expr.getDeclaredParam(), expr, appendable, false); super.appendForLoopParameter(expr, appendable); }
protected void _toJavaExpression(XConstructorCall expr, ITreeAppendable b) { String varName = getReferenceName(expr, b); if (varName != null) { b.trace(expr, false).append(varName); } else { constructorCallToJavaExpression(expr, b); } }
protected void executeThenPart(XSwitchExpression expr, String switchResultName, XExpression then, ITreeAppendable b, boolean isReferenced) { final boolean canBeReferenced = isReferenced && !isPrimitiveVoid(then); internalToJavaStatement(then, b, canBeReferenced); if (canBeReferenced) { b.newLine().append(switchResultName).append(" = "); internalToConvertedExpression(then, b, getLightweightType(expr)); b.append(";"); } }
protected void _toJavaStatement(final XConstructorCall expr, ITreeAppendable b, final boolean isReferenced) { for (XExpression arg : expr.getArguments()) { prepareExpression(arg, b); } if (!isReferenced) { b.newLine(); constructorCallToJavaExpression(expr, b); b.append(";"); } else if (isVariableDeclarationRequired(expr, b, true)) { Later later = new Later() { @Override public void exec(ITreeAppendable appendable) { constructorCallToJavaExpression(expr, appendable); } }; declareFreshLocalVariable(expr, b, later); } }
protected void appendCatchClause(XCatchClause catchClause, boolean parentIsReferenced, String parentVariable, ITreeAppendable appendable) { JvmTypeReference type = catchClause.getDeclaredParam().getParameterType(); final String declaredParamName = makeJavaIdentifier(catchClause.getDeclaredParam().getName()); final String name = appendable.declareVariable(catchClause.getDeclaredParam(), declaredParamName); appendable.append("if ("); while(iter.hasNext()) { appendable.append(parentVariable).append(" instanceof "); serialize(iter.next(), catchClause, appendable); if (iter.hasNext()) { appendable.append(" || "); typeToUse = resolveSynonymType((JvmSynonymTypeReference) type, catchClause); } else { appendable.append(parentVariable).append(" instanceof "); serialize(type, catchClause, appendable); if (!XbaseUsageCrossReferencer.find(catchClause.getDeclaredParam(), catchClause.getExpression()).isEmpty()) { ITreeAppendable parameterAppendable = withDebugging.trace(catchClause.getDeclaredParam()); appendCatchClauseParameter(catchClause, typeToUse, name, parameterAppendable.newLine()); withDebugging.append(" = ("); serialize(typeToUse, catchClause, withDebugging); withDebugging.append(")").append(parentVariable).append(";"); final boolean canBeReferenced = parentIsReferenced && ! isPrimitiveVoid(catchClause.getExpression()); internalToJavaStatement(catchClause.getExpression(), withDebugging, canBeReferenced); if (canBeReferenced) { appendable.newLine().append(getVarName(catchClause.eContainer(), appendable)).append(" = "); internalToConvertedExpression(catchClause.getExpression(), appendable, getLightweightType((XExpression) catchClause.eContainer()));
b.openScope(); String selfVariable = null; if (needSyntheticSelfVariable(closure, type)) { b.newLine().append("final "); b.append(type).append(" "); final LightweightTypeReference returnType = getClosureOperationReturnType(type, operation); appendOperationVisibility(b, operation); if (!operation.getTypeParameters().isEmpty()) { appendTypeParameters(b, operation, type); for (int i = 0; i < closureParams.size(); i++) { JvmFormalParameter closureParam = closureParams.get(i); LightweightTypeReference parameterType = getClosureOperationParameterType(type, operation, i); if (isVarArgs && i == closureParams.size()-1 && parameterType.isArray()) { appendClosureParameterVarArgs(closureParam, parameterType.getComponentType(), b); } else { appendClosureParameter(closureParam, parameterType, b); b.append(" throws "); for (int i = 0; i < operation.getExceptions().size(); ++i) { serialize(operation.getExceptions().get(i), closure, b, false, false, false, false); if(i != operation.getExceptions().size() -1) b.append(", "); b.increaseIndentation(); if (selfVariable == null) { reassignThisInClosure(b, type.getType()); } else {
protected void _toJavaStatement(XTryCatchFinallyExpression expr, ITreeAppendable outerAppendable, boolean isReferenced) { ITreeAppendable b = outerAppendable.trace(expr, false); if (isReferenced && !isPrimitiveVoid(expr)) { declareSyntheticVariable(expr, b); } b.newLine().append("try {").increaseIndentation(); final boolean canBeReferenced = isReferenced && !isPrimitiveVoid(expr.getExpression()); internalToJavaStatement(expr.getExpression(), b, canBeReferenced); if (canBeReferenced) { b.newLine().append(getVarName(expr, b)).append(" = "); internalToConvertedExpression(expr.getExpression(), b, getLightweightType(expr)); b.append(";"); } b.decreaseIndentation().newLine().append("}"); appendCatchAndFinally(expr, b, isReferenced); }
protected void _toJavaStatement(final XSynchronizedExpression synchronizedExpression, final ITreeAppendable b, boolean isReferenced) { if (isReferenced) { declareSyntheticVariable(synchronizedExpression, b); } ITreeAppendable synchronizedAppendable = b.trace(synchronizedExpression, true); XExpression param = synchronizedExpression.getParam(); if (!canCompileToJavaExpression(param, b)) internalToJavaStatement(param, synchronizedAppendable, isReferenced); synchronizedAppendable.newLine().append("synchronized ("); internalToJavaExpression(param, synchronizedAppendable); synchronizedAppendable.append(") {").increaseIndentation(); synchronizedAppendable.openPseudoScope(); XExpression expression = synchronizedExpression.getExpression(); internalToJavaStatement(expression, b, isReferenced); if (isReferenced) { b.newLine().append(getVarName(synchronizedExpression, synchronizedAppendable)).append(" = "); internalToConvertedExpression(expression, b, getLightweightType(synchronizedExpression)); b.append(";"); } synchronizedAppendable.closeScope(); synchronizedAppendable.decreaseIndentation().newLine().append("}"); }
protected void _toJavaStatement(XIfExpression expr, ITreeAppendable b, boolean isReferenced) { if (isReferenced) declareSyntheticVariable(expr, b); internalToJavaStatement(expr.getIf(), b, true); b.newLine().append("if ("); internalToJavaExpression(expr.getIf(), b); b.append(") {").increaseIndentation(); final boolean canBeReferenced = isReferenced && !isPrimitiveVoid(expr.getThen()); internalToJavaStatement(expr.getThen(), b, canBeReferenced); if (canBeReferenced) { b.newLine(); b.append(getVarName(expr, b)); b.append(" = "); internalToConvertedExpression(expr.getThen(), b, getLightweightType(expr)); b.append(";"); if (expr.getElse() != null) { b.append(" else {").increaseIndentation(); final boolean canElseBeReferenced = isReferenced && !isPrimitiveVoid(expr.getElse()); internalToJavaStatement(expr.getElse(), b, canElseBeReferenced); if (canElseBeReferenced) { b.newLine(); b.append(getVarName(expr, b)); b.append(" = "); internalToConvertedExpression(expr.getElse(), b, getLightweightType(expr)); b.append(";");
boolean needBraces = !bracesAreAddedByOuterStructure(expr); if (needBraces) { loopAppendable.newLine().increaseIndentation().append("{"); XExpression initExpression = initExpressions.get(i); if (i < initExpressions.size() - 1) { internalToJavaStatement(initExpression, loopAppendable, false); } else { internalToJavaStatement(initExpression, loopAppendable, isReferenced); if (isReferenced) { loopAppendable.newLine().append(getVarName(expr, loopAppendable)).append(" = ("); internalToConvertedExpression(initExpression, loopAppendable, getLightweightType(expr)); loopAppendable.append(");"); internalToJavaStatement(expression, loopAppendable, true); loopAppendable.newLine().append("boolean ").append(varName).append(" = "); internalToJavaExpression(expression, loopAppendable); loopAppendable.append(";"); } else { internalToJavaStatement(eachExpression, loopAppendable, false); internalToJavaStatement(updateExpression, loopAppendable, false); if (!isEarlyExit(eachExpression)) { if (expression != null) { internalToJavaStatement(expression, loopAppendable, true); loopAppendable.newLine().append(varName).append(" = "); internalToJavaExpression(expression, loopAppendable);
return; if (expr.getExpressions().size()==1) { internalToJavaStatement(expr.getExpressions().get(0), b, isReferenced); return; declareSyntheticVariable(expr, b); boolean needsBraces = isReferenced || !bracesAreAddedByOuterStructure(expr); if (needsBraces) { b.newLine().append("{").increaseIndentation(); XExpression ex = expressions.get(i); if (i < expressions.size() - 1) { internalToJavaStatement(ex, b, false); } else { internalToJavaStatement(ex, b, isReferenced); if (isReferenced) { b.newLine().append(getVarName(expr, b)).append(" = "); internalToConvertedExpression(ex, b, getLightweightType(expr)); b.append(";");
if (firstInitExpression instanceof XVariableDeclaration) { XVariableDeclaration variableDeclaration = (XVariableDeclaration) firstInitExpression; LightweightTypeReference type = appendVariableTypeAndName(variableDeclaration, loopAppendable); loopAppendable.append(" = "); if (variableDeclaration.getRight() != null) { compileAsJavaExpression(variableDeclaration.getRight(), loopAppendable, type); } else { appendDefaultLiteral(loopAppendable, type); compileAsJavaExpression(initExpression, loopAppendable, getLightweightType(initExpression)); if (expression != null) { loopAppendable.append(" "); internalToJavaExpression(expression, loopAppendable); internalToJavaExpression(updateExpression, loopAppendable); internalToJavaStatement(eachExpression, loopAppendable, false);
/** * @param isReferenced unused in this context but necessary for dispatch signature */ protected void _toJavaStatement(XVariableDeclaration varDeclaration, ITreeAppendable b, boolean isReferenced) { if (varDeclaration.getRight() != null) { internalToJavaStatement(varDeclaration.getRight(), b, true); } b.newLine(); LightweightTypeReference type = appendVariableTypeAndName(varDeclaration, b); b.append(" = "); if (varDeclaration.getRight() != null) { internalToConvertedExpression(varDeclaration.getRight(), b, type); } else { appendDefaultLiteral(b, type); } b.append(";"); }
protected void _toJavaExpression(XCastedExpression expr, ITreeAppendable b) { b.append("(("); serialize(expr.getType(), expr, b); b.append(") "); internalToConvertedExpression(expr.getTarget(), b, getLightweightType(expr)); b.append(")"); }
/** * @param isReferenced unused in this context but necessary for dispatch signature */ protected void _toJavaStatement(XReturnExpression expr, ITreeAppendable b, boolean isReferenced) { if (expr.getExpression()!=null) { internalToJavaStatement(expr.getExpression(), b, true); b.newLine().append("return "); LightweightTypeReference returnTypeToCompile = findRealReturnType(expr); internalToConvertedExpression(expr.getExpression(), b, returnTypeToCompile); b.append(";"); } else { b.newLine().append("return;"); } }
return false; if (expr instanceof XMemberFeatureCall && isVariableDeclarationRequired((XMemberFeatureCall) expr, b)) return true; EObject container = expr.eContainer(); List<XExpression> siblings = ((XBlockExpression) container).getExpressions(); if (siblings.get(siblings.size() - 1) == expr) { return isVariableDeclarationRequired(getFeatureCall(expr), expr, b); for (XExpression arg : getActualArguments(a)) { if (isVariableDeclarationRequired(arg, b, recursive)) { return true;
/** * @param isReferenced unused in this context but necessary for dispatch signature */ protected void _toJavaStatement(XForLoopExpression expr, ITreeAppendable b, boolean isReferenced) { internalToJavaStatement(expr.getForExpression(), b, true); b.newLine(); ITreeAppendable loopAppendable = b.trace(expr); loopAppendable.append("for ("); ITreeAppendable parameterAppendable = loopAppendable.trace(expr.getDeclaredParam()); appendForLoopParameter(expr, parameterAppendable); loopAppendable.append(" : "); internalToJavaExpression(expr.getForExpression(), loopAppendable); loopAppendable.append(") {").increaseIndentation(); internalToJavaStatement(expr.getEachExpression(), loopAppendable, false); loopAppendable.decreaseIndentation().newLine().append("}"); }
boolean skipTypeName = false; if (expectedType != null && expectedType.isArray()) { if (canUseArrayInitializer(literal, b)) { skipTypeName = true; b.append(", "); isFirst = false; internalToJavaExpression(element, b); appendImmutableCollectionExpression(literal, b, "unmodifiableList", CollectionLiterals.class, "newArrayList");