List of usage examples for org.eclipse.jdt.core.dom AST newVariableDeclarationStatement
public VariableDeclarationStatement newVariableDeclarationStatement(VariableDeclarationFragment fragment)
From source file:cn.ieclipse.adt.ext.jdt.SourceGenerator.java
License:Apache License
private static void genInnerSQLiteOpenHelper(AnonymousClassDeclaration acd, AST ast, List<String> tableCreators) { MethodDeclaration md = ast.newMethodDeclaration(); md.modifiers().addAll(ast.newModifiers((Modifier.PUBLIC))); md.setReturnType2(ast.newPrimitiveType(PrimitiveType.VOID)); md.setName(ast.newSimpleName("onCreate")); SingleVariableDeclaration svd = ast.newSingleVariableDeclaration(); svd.setName(ast.newSimpleName("db")); svd.setType(ast.newSimpleType(ast.newSimpleName("SQLiteDatabase"))); md.parameters().add(svd);//from ww w.j ava 2 s. c o m Block innerBlock = ast.newBlock(); md.setBody(innerBlock); VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment(); vdf.setName(ast.newSimpleName("sql")); StringLiteral sl = ast.newStringLiteral(); sl.setLiteralValue(""); vdf.setInitializer(sl); VariableDeclarationStatement vds = ast.newVariableDeclarationStatement(vdf); vds.setType(ast.newSimpleType(ast.newSimpleName("String"))); innerBlock.statements().add(vds); for (String creator : tableCreators) { String[] lines = creator.split(SourceAnalysis.LF); for (String line : lines) { Assignment a = ast.newAssignment(); a.setOperator(Assignment.Operator.PLUS_ASSIGN); a.setLeftHandSide(ast.newSimpleName("sql")); StringLiteral temp = ast.newStringLiteral(); temp.setLiteralValue(line); a.setRightHandSide(temp); innerBlock.statements().add(ast.newExpressionStatement(a)); } MethodInvocation mi = ast.newMethodInvocation(); mi.setName(ast.newSimpleName("execSQL")); mi.setExpression(ast.newSimpleName("db")); mi.arguments().add(ast.newSimpleName("sql")); innerBlock.statements().add(ast.newExpressionStatement(mi)); } acd.bodyDeclarations().add(md); // onUpgrade md = ast.newMethodDeclaration(); md.modifiers().addAll(ast.newModifiers((Modifier.PUBLIC))); md.setReturnType2(ast.newPrimitiveType(PrimitiveType.VOID)); md.setName(ast.newSimpleName("onUpgrade")); svd = ast.newSingleVariableDeclaration(); svd.setName(ast.newSimpleName("db")); svd.setType(ast.newSimpleType(ast.newSimpleName("SQLiteDatabase"))); md.parameters().add(svd); svd = ast.newSingleVariableDeclaration(); svd.setName(ast.newSimpleName("oldVersion")); svd.setType(ast.newPrimitiveType(PrimitiveType.INT)); md.parameters().add(svd); svd = ast.newSingleVariableDeclaration(); svd.setName(ast.newSimpleName("newVersion")); svd.setType(ast.newPrimitiveType(PrimitiveType.INT)); md.parameters().add(svd); innerBlock = ast.newBlock(); md.setBody(innerBlock); acd.bodyDeclarations().add(md); }
From source file:com.google.devtools.j2objc.translate.ASTFactory.java
License:Apache License
public static VariableDeclarationStatement newVariableDeclarationStatement(AST ast, VariableDeclarationFragment fragment) { IVariableBinding varBinding = Types.getVariableBinding(fragment); VariableDeclarationStatement decl = ast.newVariableDeclarationStatement(fragment); decl.setType(newType(ast, varBinding.getType())); ASTUtil.getModifiers(decl).addAll(newModifiers(ast, varBinding.getModifiers())); return decl;//from www . jav a 2 s. co m }
From source file:com.idega.eclipse.ejbwizards.IDOEntityCreator.java
License:Open Source License
private Statement getIDOCheckOutStatement(AST ast, Set imports) { VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment(); vdf.setName(ast.newSimpleName("entity")); VariableDeclarationStatement vds = ast.newVariableDeclarationStatement(vdf); vds.setType(ast.newSimpleType(ast.newSimpleName("IDOEntity"))); imports.add("com.idega.data.IDOEntity"); ThisExpression thisExpression = ast.newThisExpression(); MethodInvocation mi = ast.newMethodInvocation(); mi.setExpression(thisExpression);/*from ww w . j a v a 2 s .c o m*/ mi.setName(ast.newSimpleName("idoCheckOutPooledEntity")); vdf.setInitializer(mi); return vds; }
From source file:com.idega.eclipse.ejbwizards.IDOEntityCreator.java
License:Open Source License
private Statement getDataCollectingStatement(AST ast, String returnType, String variableName, String methodName, String[] parameterNames) { VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment(); vdf.setName(ast.newSimpleName(variableName)); VariableDeclarationStatement vds = ast.newVariableDeclarationStatement(vdf); vds.setType(getType(ast, returnType)); CastExpression ce = ast.newCastExpression(); ce.setType(ast.newSimpleType(ast.newSimpleName(getType().getTypeQualifiedName()))); ce.setExpression(ast.newSimpleName("entity")); ParenthesizedExpression pe = ast.newParenthesizedExpression(); pe.setExpression(ce);/*w ww. j a v a 2 s . c o m*/ MethodInvocation mi = ast.newMethodInvocation(); mi.setExpression(pe); mi.setName(ast.newSimpleName(methodName)); vdf.setInitializer(mi); for (int i = 0; i < parameterNames.length; i++) { mi.arguments().add(ast.newSimpleName(parameterNames[i])); } return vds; }
From source file:de.dentrassi.varlink.generator.JdtGenerator.java
License:Open Source License
@SuppressWarnings("unchecked") private void createInternalMethod(final TypeDeclaration parentTypeDeclaration, final MethodInformation m, final MethodDeclaration md) { final AST ast = md.getAST(); final Block body = ast.newBlock(); md.setBody(body);//from ww w . j ava2 s . com /* * return this.connection.call(CallRequest.of("io.systemd.network.List")) * .thenApply(cr -> { check(cr); * * final Iterator<JsonElement> i = cr.getParameters().values().iterator(); * * return asList( this.varlink .fromJson( Netdev[].class, i.next())); }); } */ // add arguments if (!m.getParameters().isEmpty()) { // code: Map<String,Object> parameters = new HashMap<> (); final VariableDeclarationFragment parameters = ast.newVariableDeclarationFragment(); parameters.setName(ast.newSimpleName("parameters")); final VariableDeclarationStatement decl = ast.newVariableDeclarationStatement(parameters); body.statements().add(decl); final ParameterizedType map = ast.newParameterizedType(ast.newSimpleType(ast.newName("java.util.Map"))); map.typeArguments().add(ast.newSimpleType(ast.newName("java.lang.String"))); map.typeArguments().add(ast.newSimpleType(ast.newName("java.lang.Object"))); decl.setType(map); final ClassInstanceCreation init = ast.newClassInstanceCreation(); init.setType(ast.newParameterizedType(ast.newSimpleType(ast.newName("java.util.HashMap")))); init.arguments().add(ast.newNumberLiteral(Integer.toString(m.getParameters().size()))); parameters.setInitializer(init); for (final String argName : m.getParameters().keySet()) { final MethodInvocation mi = ast.newMethodInvocation(); mi.setExpression(ast.newSimpleName("parameters")); mi.setName(ast.newSimpleName("put")); mi.arguments().add(JdtHelper.newStringLiteral(ast, argName)); mi.arguments().add(ast.newSimpleName(argName)); } } // return final ReturnStatement ret = ast.newReturnStatement(); body.statements().add(ret); final MethodInvocation mi = ast.newMethodInvocation(); mi.setName(ast.newSimpleName("call")); final FieldAccess fa = ast.newFieldAccess(); fa.setExpression(ast.newThisExpression()); fa.setName(ast.newSimpleName("connection")); mi.setExpression(fa); final MethodInvocation cr = ast.newMethodInvocation(); cr.setExpression(ast.newName("de.dentrassi.varlink.spi.CallRequest")); cr.setName(ast.newSimpleName("of")); cr.arguments().add(newStringLiteral(ast, m.getInterface().getName() + "." + toUpperFirst(m.getName()))); if (!m.getParameters().isEmpty()) { cr.arguments().add(ast.newSimpleName("parameters")); } mi.arguments().add(cr); final MethodInvocation thenApply = ast.newMethodInvocation(); thenApply.setName(ast.newSimpleName("thenApply")); thenApply.setExpression(mi); // add transformation final LambdaExpression le = ast.newLambdaExpression(); le.setParentheses(false); thenApply.arguments().add(le); final VariableDeclarationFragment p = ast.newVariableDeclarationFragment(); p.setName(ast.newSimpleName("result")); le.parameters().add(p); final Block transform = ast.newBlock(); le.setBody(transform); { // check result final MethodInvocation check = ast.newMethodInvocation(); check.setName(ast.newSimpleName("checkError")); transform.statements().add(ast.newExpressionStatement(check)); check.arguments().add(ast.newSimpleName("result")); } if (m.getReturnTypes().isEmpty()) { final ReturnStatement transformRet = ast.newReturnStatement(); transformRet.setExpression(ast.newNullLiteral()); transform.statements().add(transformRet); } else { final int returns = m.getReturnTypes().size(); if (returns > 0) { // return this.varlink.fromJson(DriveCondition.class, result.getParameters()); // return this.varlink.fromJson(DriveCondition.class, // result.getFirstParameter()); final FieldAccess varlink = ast.newFieldAccess(); varlink.setExpression(ast.newThisExpression()); varlink.setName(ast.newSimpleName("varlink")); final MethodInvocation fromJson = ast.newMethodInvocation(); fromJson.setExpression(varlink); fromJson.setName(ast.newSimpleName("fromJson")); // FIXME: add to parent { final ParameterizedType ttt = ast .newParameterizedType(ast.newSimpleType(ast.newName(TYPE_TOKEN_TYPE_NAME))); ttt.typeArguments().add(m.createMainReturnType(ast)); final ClassInstanceCreation tt = ast.newClassInstanceCreation(); tt.setType(JdtHelper.copyNode(ast, ttt)); final AnonymousClassDeclaration decl = ast.newAnonymousClassDeclaration(); tt.setAnonymousClassDeclaration(decl); final MethodInvocation getType = ast.newMethodInvocation(); getType.setExpression(tt); getType.setName(ast.newSimpleName("getType")); final VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment(); vdf.setName(ast.newSimpleName(m.getName() + "_returnTypeToken")); vdf.setInitializer(getType); final FieldDeclaration fd = ast.newFieldDeclaration(vdf); fd.setType(ast.newSimpleType(ast.newName("java.lang.reflect.Type"))); make(fd, PRIVATE_KEYWORD, FINAL_KEYWORD, STATIC_KEYWORD); parentTypeDeclaration.bodyDeclarations().add(fd); } fromJson.arguments().add(ast.newSimpleName(m.getName() + "_returnTypeToken")); // json fragment final MethodInvocation fragment = ast.newMethodInvocation(); if (returns == 1) { fragment.setName(ast.newSimpleName("getFirstParameter")); } else { fragment.setName(ast.newSimpleName("getParameters")); } fragment.setExpression(ast.newSimpleName("result")); fromJson.arguments().add(fragment); // return final ReturnStatement transformRet = ast.newReturnStatement(); transformRet.setExpression(fromJson); transform.statements().add(transformRet); } // FIXME: handle return type // FIXME: handle n } // set return ret.setExpression(thenApply); }
From source file:de.ovgu.cide.export.physical.ahead.JakFeatureRefactorer.java
License:Open Source License
/** * creates a Super call (actually a super call that is replaced by Super * when printing the Jak file with the JakPrettyPrinter). * /* ww w . ja v a2 s .co m*/ * @param currentMethod * @param ast * @param withReturn * if true then the result of the super invocation is returned * (return Super...), otherwise it is placed in a local variable * called result * @param formal * local variable to which the result (if any) should be * assigned. if formal==null, then a new variable is created with * the name result (ChK: is there a usecase for this?) * @return */ static Statement createSuperCall(MethodDeclaration currentMethod, AST ast, boolean withReturn, Formal formal) { Statement superCall; if (currentMethod.isConstructor()) { assert !withReturn; /** * super constructor calls are implicit in Jak. so there is no * statement to call a super constructor. */ superCall = null; } else { SuperMethodInvocation superCallExpr = ast.newSuperMethodInvocation(); SuperCallHelper.addSuperLayerCall(superCallExpr); superCallExpr.setName(ast.newSimpleName(currentMethod.getName().getIdentifier())); String types = ""; for (Iterator<SingleVariableDeclaration> iter = currentMethod.parameters().iterator(); iter .hasNext();) { SingleVariableDeclaration param = iter.next(); SimpleName v = ast.newSimpleName(param.getName().getIdentifier()); superCallExpr.arguments().add(v); VariableDeclaration decl = LocalVariableHelper.findVariableDeclaration(param.getName()); if (decl != null) LocalVariableHelper.addLocalVariableAccess(v, decl); types += getTypeString(param.getType()); if (iter.hasNext()) types += ", "; } SuperTypeHelper.cacheTypes(superCallExpr, types); if (RefactoringUtils.isVoid(currentMethod.getReturnType2())) { superCall = ast.newExpressionStatement(superCallExpr); } else { if (withReturn) { ReturnStatement returnStatement = ast.newReturnStatement(); returnStatement.setExpression(superCallExpr); superCall = returnStatement; } else { if (formal == null) { VariableDeclarationFragment returnVariable = ast.newVariableDeclarationFragment(); returnVariable.setName(ast.newSimpleName("result")); VariableDeclarationStatement variableDecl = ast .newVariableDeclarationStatement(returnVariable); variableDecl.setType( (Type) ASTNode.copySubtree(currentMethod.getAST(), currentMethod.getReturnType2())); returnVariable.setInitializer(superCallExpr); superCall = variableDecl; } else { Assignment assign = ast.newAssignment(); SimpleName v = ast.newSimpleName(formal.name); assign.setLeftHandSide(v); LocalVariableHelper.addLocalVariableAccess(v, formal); assign.setRightHandSide(superCallExpr); superCall = ast.newExpressionStatement(assign); } } } } return superCall; }
From source file:org.autorefactor.refactoring.rules.ReduceVariableScopeRefactoring.java
License:Open Source License
private void replace(VariableAccess varDecl, VariableAccess varAccess) { final ASTBuilder b = this.ctx.getASTBuilder(); final AST ast = b.getAST(); final ASTNode scope = varAccess.getScope(); final Name varName = varAccess.getVariableName(); final Type varType = getType(varDecl.getVariableName().getParent()); if (scope instanceof Block) { final List<Statement> stmts = statements((Block) scope); for (int i = 0; i < stmts.size(); i++) { final Statement stmt = stmts.get(i); final Expression parentExpr = getAncestor(varName, Expression.class); // FIXME i=0 final Statement parentStmt = getAncestor(parentExpr, Statement.class); // FIXME i=0 if (stmt.equals(parentStmt)) { final VariableDeclarationFragment vdf = getVariableDeclarationFragment(parentExpr, varName); final VariableDeclarationStatement vds = ast.newVariableDeclarationStatement(vdf); vds.setType(varType);/*w w w . ja v a 2s. com*/ this.ctx.getRefactorings().replace(stmt, vds); break; } } } else if (scope instanceof EnhancedForStatement) { final EnhancedForStatement efs = (EnhancedForStatement) scope; final EnhancedForStatement newEfs = b.copy(efs); newEfs.setParameter(b.copy(efs.getParameter())); newEfs.setExpression(b.copy(efs.getExpression())); final Statement parentStmt = getAncestor(varName, Statement.class); if (equalNotNull(efs.getBody(), parentStmt)) { newEfs.setBody(copy(efs.getBody(), varName)); } this.ctx.getRefactorings().replace(efs, newEfs); } else if (scope instanceof ForStatement) { final ForStatement fs = (ForStatement) scope; final ForStatement newFs = b.copy(fs); final List<Expression> initializers = initializers(newFs); if (initializers.size() == 1) { final Expression init = initializers.remove(0); final VariableDeclarationFragment vdf = getVariableDeclarationFragment(init, varName); final VariableDeclarationExpression vde = ast.newVariableDeclarationExpression(vdf); vde.setType(varType); initializers.add(vde); this.ctx.getRefactorings().replace(fs, newFs); // TODO JNR // if (equalNotNull(fs.getBody(), parentStmt)) { // newFs.setBody(copy(fs.getBody())); // } } else { throw new NotImplementedException(scope, "for more than one initializer in for loop."); } } else if (scope instanceof WhileStatement) { final WhileStatement ws = (WhileStatement) scope; final WhileStatement newWs = ast.newWhileStatement(); newWs.setExpression(b.copy(ws.getExpression())); final Statement parentStmt = getAncestor(varName, Statement.class); if (equalNotNull(ws.getBody(), parentStmt)) { newWs.setBody(copy(ws.getBody(), varName)); } this.ctx.getRefactorings().replace(ws, newWs); } else if (scope instanceof IfStatement) { final IfStatement is = (IfStatement) scope; final IfStatement newIs = ast.newIfStatement(); newIs.setExpression(b.copy(is.getExpression())); final Statement parentStmt = getAncestor(varName, Statement.class); if (equalNotNull(is.getThenStatement(), parentStmt)) { newIs.setThenStatement(copy(is.getThenStatement(), varName)); if (is.getElseStatement() != null) { newIs.setElseStatement(b.copy(is.getElseStatement())); } this.ctx.getRefactorings().replace(is, newIs); } else if (equalNotNull(is.getElseStatement(), parentStmt)) { if (is.getThenStatement() != null) { newIs.setThenStatement(b.copy(is.getThenStatement())); } newIs.setElseStatement(copy(is.getElseStatement(), varName)); this.ctx.getRefactorings().replace(is, newIs); } else { throw new IllegalStateException(is, "Parent statement should be inside the then or else statement of this if statement: " + is); } } else { throw new NotImplementedException(scope); } }
From source file:org.eclipse.wb.internal.core.model.variable.FieldUniqueVariableSupport.java
License:Open Source License
@Override public void convertFieldToLocal() throws Exception { AstEditor editor = m_javaInfo.getEditor(); // prepare current information VariableDeclaration oldFragment = m_declaration; FieldDeclaration oldField = (FieldDeclaration) oldFragment.getParent(); String typeString = editor.getSource(oldField.getType()); // variable is first place where JavaInfo is assigned Assignment assignment = (Assignment) m_variable.getParent(); Assert.isTrue(assignment.getLeftHandSide() == m_variable); Expression oldInitializer = assignment.getRightHandSide(); Statement oldStatement = (Statement) assignment.getParent(); ITypeBinding typeBinding = AstNodeUtils.getTypeBinding(oldField.getType()); // rename variable to make it local-like String localName = m_utils.convertName(assignment.getStartPosition(), getName(), JavaCore.CODEASSIST_FIELD_PREFIXES, JavaCore.CODEASSIST_FIELD_SUFFIXES, JavaCore.CODEASSIST_LOCAL_PREFIXES, JavaCore.CODEASSIST_LOCAL_SUFFIXES, m_declaration); setName(localName);/*from w ww.j a v a 2s .c o m*/ // replace "this.fieldName" with "localName" { for (Expression reference : getReferences()) { if (reference instanceof FieldAccess) { SimpleName simpleReference = parseVariableSimpleName(reference.getStartPosition(), localName, typeBinding); editor.replaceSubstring(reference, localName); AstEditor.replaceNode(reference, simpleReference); if (reference == m_variable) { m_variable = simpleReference; } } } } // add type source (before changes in AST because we insert new nodes) Type newType; { int oldStart = m_variable.getStartPosition(); editor.replaceSubstring(oldStart, 0, typeString + " "); newType = editor.getParser().parseType(oldStart, oldField.getType()); } // replace assignment with variable declaration SimpleName localVariable; { AST ast = m_variable.getAST(); // prepare new fragment, reuse variable and initializer VariableDeclarationFragment newFragment = ast.newVariableDeclarationFragment(); { assignment.setLeftHandSide(ast.newSimpleName("__foo")); editor.replaceSubstring(m_variable, localName); localVariable = parseVariableSimpleName(m_variable.getStartPosition(), localName, typeBinding); m_variable = localVariable; newFragment.setName(localVariable); } { assignment.setRightHandSide(ast.newSimpleName("__bar")); newFragment.setInitializer(oldInitializer); } AstNodeUtils.setSourceRange(newFragment, m_variable, oldInitializer); // prepare new statement VariableDeclarationStatement newStatement = ast.newVariableDeclarationStatement(newFragment); newStatement.setType(newType); AstNodeUtils.setSourceRange(newStatement, newType, oldStatement); // replace old statement in AST { List<Statement> statements = DomGenerics.statements((Block) oldStatement.getParent()); int index = statements.indexOf(oldStatement); statements.set(index, newStatement); } } // remove old field editor.removeVariableDeclaration(oldFragment); // use local variable support m_javaInfo.setVariableSupport(new LocalUniqueVariableSupport(m_javaInfo, localVariable)); }
From source file:org.eclipse.wb.internal.core.model.variable.LocalReuseVariableSupport.java
License:Open Source License
@Override public void setType(String newTypeName) throws Exception { // if old declaration is with our initializer, split it on declaration and assignment if (m_declaration.getName() == m_variable) { splitVariable();/*w w w .j ava2 s . c om*/ } // check that existing assignment is part of ExpressionStatement Assignment oldAssignment; ExpressionStatement oldStatement; { Assert.isTrue(m_variable.getLocationInParent() == Assignment.LEFT_HAND_SIDE_PROPERTY && m_variable.getParent().getLocationInParent() == ExpressionStatement.EXPRESSION_PROPERTY, "Variable should be part of Assignment in ExpressionStatement, for " + AstNodeUtils.getEnclosingStatement(m_variable)); oldAssignment = (Assignment) m_variable.getParent(); oldStatement = (ExpressionStatement) AstNodeUtils.getEnclosingStatement(oldAssignment); } // convert Assignment into VariableDeclarationStatement with required Type { AstEditor editor = m_javaInfo.getEditor(); AST ast = m_variable.getAST(); // initial values int position = oldStatement.getStartPosition(); String source = ""; // add type Type newType; { newType = editor.getParser().parseQualifiedType(position, newTypeName); source += newTypeName + " "; } // add variable SimpleName newVariable; { // prepare identifier String identifier; { identifier = AstNodeUtils.getVariableName(m_variable); identifier = editor.getUniqueVariableName(position, identifier, null); replaceComponentReferences(identifier); } // prepare variable newVariable = editor.getParser().parseVariable(position + source.length(), identifier, null, AstNodeUtils.getTypeBinding(newType), false, Modifier.NONE); source += identifier; } // add " = " { source += " = "; } // add initializer Expression newInitializer; { newInitializer = oldAssignment.getRightHandSide(); oldAssignment.setRightHandSide(ast.newSimpleName("__bar__")); String initializerSource = editor.getSource(newInitializer); AstNodeUtils.moveNode(newInitializer, position + source.length()); source += initializerSource; } // create fragment VariableDeclarationFragment newFragment; { newFragment = ast.newVariableDeclarationFragment(); newFragment.setName(newVariable); newFragment.setInitializer(newInitializer); AstNodeUtils.setSourceRange(newFragment, newVariable, newInitializer); } // create statement VariableDeclarationStatement newStatement; { newStatement = ast.newVariableDeclarationStatement(newFragment); newStatement.setType(newType); AstNodeUtils.setSourceRange(newStatement, newType, newFragment, 1); source += ";"; } // replace old statement with new statement { List<Statement> statements = DomGenerics.statements((Block) oldStatement.getParent()); int index = statements.indexOf(oldStatement); // replace without "oldStatement", so its parts are not moved statements.remove(index); editor.replaceSubstring(oldStatement, source); // now we can add "newStatement", we created it already with correct positions statements.add(index, newStatement); // finalize source modifications editor.resolveImports(newStatement); } // now our JavaInfo uses LocalUniqueVariableSupport m_javaInfo.setVariableSupport(new LocalUniqueVariableSupport(m_javaInfo, newVariable)); } }
From source file:org.evosuite.testcarver.codegen.CodeGenerator.java
License:Open Source License
@SuppressWarnings("unchecked") private void createMethodCallStmt(final String packageName, final int logRecNo, final boolean postprocessing, final Block methodBlock, final AST ast) { // assumption: all necessary statements are created and there is one variable for reach referenced object final int oid = this.log.objectIds.get(logRecNo); final Object[] methodArgs = this.log.params.get(logRecNo); final String methodName = this.log.methodNames.get(logRecNo); final String methodDesc = this.log.descList.get(logRecNo); final org.objectweb.asm.Type[] methodParamTypes = org.objectweb.asm.Type.getArgumentTypes(methodDesc); final Class<?>[] methodParamTypeClasses = new Class[methodParamTypes.length]; for (int i = 0; i < methodParamTypes.length; i++) { methodParamTypeClasses[i] = getClassForName(methodParamTypes[i].getClassName()); }//from w w w . j a v a2 s . com final String typeName = this.log.oidClassNames.get(this.log.oidRecMapping.get(oid)); Class<?> type = getClassForName(typeName); // Class<?> type; // try { // type = Class.forName(typeName); // } catch (ClassNotFoundException e) { // throw new RuntimeException(e); // } final boolean haveSamePackage = type.getPackage().getName().equals(packageName); // TODO might be nicer... final Statement finalStmt; @SuppressWarnings("rawtypes") final List arguments; if (CaptureLog.OBSERVED_INIT.equals(methodName)) { /* * Person var0 = null; * { * var0 = new Person(); * } * catch(Throwable t) * { * org.uni.saarland.sw.prototype.capture.PostProcessor.captureException(<logRecNo>); * } */ // e.g. Person var0 = null; final String varName = this.createNewVarName(oid, typeName); VariableDeclarationFragment vd = ast.newVariableDeclarationFragment(); vd.setName(ast.newSimpleName(varName)); VariableDeclarationStatement stmt = ast.newVariableDeclarationStatement(vd); stmt.setType(this.createAstType(typeName, ast)); vd.setInitializer(ast.newNullLiteral()); methodBlock.statements().add(stmt); try { this.getConstructorModifiers(type, methodParamTypeClasses); } catch (Exception e) { e.printStackTrace(); } final int constructorTypeModifiers = this.getConstructorModifiers(type, methodParamTypeClasses); final boolean isPublic = java.lang.reflect.Modifier.isPublic(constructorTypeModifiers); final boolean isReflectionAccessNeeded = !isPublic && !haveSamePackage; if (isReflectionAccessNeeded) { this.isNewInstanceMethodNeeded = true; final MethodInvocation mi = this.createCallMethodOrNewInstanceCallStmt(true, ast, varName, typeName, methodName, methodArgs, methodParamTypes); arguments = null; final Assignment assignment = ast.newAssignment(); assignment.setLeftHandSide(ast.newSimpleName(varName)); assignment.setOperator(Operator.ASSIGN); final CastExpression cast = ast.newCastExpression(); cast.setType(this.createAstType(typeName, ast)); cast.setExpression(mi); assignment.setRightHandSide(cast); finalStmt = ast.newExpressionStatement(assignment); } else { // e.g. var0 = new Person(); final ClassInstanceCreation ci = ast.newClassInstanceCreation(); ci.setType(this.createAstType(typeName, ast)); final Assignment assignment = ast.newAssignment(); assignment.setLeftHandSide(ast.newSimpleName(varName)); assignment.setOperator(Operator.ASSIGN); assignment.setRightHandSide(ci); finalStmt = ast.newExpressionStatement(assignment); arguments = ci.arguments(); } } else //------------------ handling for ordinary method calls e.g. var1 = var0.doSth(); { String returnVarName = null; final String desc = this.log.descList.get(logRecNo); final String returnType = org.objectweb.asm.Type.getReturnType(desc).getClassName(); final Object returnValue = this.log.returnValues.get(logRecNo); if (!CaptureLog.RETURN_TYPE_VOID.equals(returnValue)) { Integer returnValueOID = (Integer) returnValue; // e.g. Person var0 = null; returnVarName = this.createNewVarName(returnValueOID, returnType); VariableDeclarationFragment vd = ast.newVariableDeclarationFragment(); vd.setName(ast.newSimpleName(returnVarName)); VariableDeclarationStatement stmt = ast.newVariableDeclarationStatement(vd); stmt.setType(this.createAstType(returnType, ast)); vd.setInitializer(ast.newNullLiteral()); methodBlock.statements().add(stmt); } final String varName = this.oidToVarMapping.get(oid); final int methodTypeModifiers = this.getMethodModifiers(type, methodName, methodParamTypeClasses); final boolean isPublic = java.lang.reflect.Modifier.isPublic(methodTypeModifiers); final boolean isReflectionAccessNeeded = !isPublic && !haveSamePackage; // e.g. Person var0 = var1.getPerson("Ben"); final MethodInvocation mi; if (isReflectionAccessNeeded) { this.isCallMethodMethodNeeded = true; mi = this.createCallMethodOrNewInstanceCallStmt(false, ast, varName, typeName, methodName, methodArgs, methodParamTypes); arguments = null; if (returnVarName != null) { final Assignment assignment = ast.newAssignment(); assignment.setLeftHandSide(ast.newSimpleName(returnVarName)); assignment.setOperator(Operator.ASSIGN); final CastExpression cast = ast.newCastExpression(); cast.setType(this.createAstType(returnType, ast)); cast.setExpression(mi); assignment.setRightHandSide(cast); finalStmt = ast.newExpressionStatement(assignment); } else { finalStmt = ast.newExpressionStatement(mi); } } else { mi = ast.newMethodInvocation(); if (this.log.isStaticCallList.get(logRecNo)) { // can only happen, if this is a static method call (because constructor statement has been reported) final String tmpType = this.log.oidClassNames.get(this.log.oidRecMapping.get(oid)); mi.setExpression(ast.newName(tmpType.split("\\."))); } else { mi.setExpression(ast.newSimpleName(varName)); } mi.setName(ast.newSimpleName(methodName)); arguments = mi.arguments(); if (returnVarName != null) { final Assignment assignment = ast.newAssignment(); assignment.setLeftHandSide(ast.newSimpleName(returnVarName)); assignment.setOperator(Operator.ASSIGN); assignment.setRightHandSide(mi); finalStmt = ast.newExpressionStatement(assignment); } else { finalStmt = ast.newExpressionStatement(mi); } } } if (postprocessing) { final TryStatement tryStmt = this.createTryStatementForPostProcessing(ast, finalStmt, logRecNo); methodBlock.statements().add(tryStmt); } else { if (this.failedRecords.contains(logRecNo)) { // we just need an empty catch block to preserve program flow final TryStatement tryStmt = this.createTryStmtWithEmptyCatch(ast, finalStmt); methodBlock.statements().add(tryStmt); } else { methodBlock.statements().add(finalStmt); } } if (arguments != null) { // final String methodDesc = this.log.descList.get(logRecNo); // final org.objectweb.asm.Type[] methodParamTypes = org.objectweb.asm.Type.getArgumentTypes(methodDesc); Class<?> methodParamType; Class<?> argType; Integer arg; // is either an oid or null for (int i = 0; i < methodArgs.length; i++) { arg = (Integer) methodArgs[i]; if (arg == null) { arguments.add(ast.newNullLiteral()); } else { methodParamType = CaptureUtil.getClassFromDesc(methodParamTypes[i].getDescriptor()); argType = this.oidToTypeMapping.get(arg); if (methodParamType.isAssignableFrom(argType)) { arguments.add(ast.newSimpleName(this.oidToVarMapping.get(arg))); } else { // we need an up-cast final CastExpression cast = ast.newCastExpression(); cast.setType(ast.newSimpleType(ast.newName(methodParamType.getName()))); cast.setExpression(ast.newSimpleName(this.oidToVarMapping.get(arg))); arguments.add(cast); } } } } }