// Generate a statement with assignment // E.g. input: x.f(y) ==> x = x.f(y); public static ExpressionStatement genAssignmentStatement(Expression exp) { Assignment assignExp = AST.newAST(AST.JLS8).newAssignment(); // generate a new left hand side variable assignExp.setLeftHandSide( (Expression) ASTNode.copySubtree(assignExp.getAST(), genSimpleName(VariableGenerator.genVar()))); assignExp.setRightHandSide((Expression) ASTNode.copySubtree(assignExp.getAST(), exp)); assignExp.setOperator(Assignment.Operator.ASSIGN); AST newAst = AST.newAST(AST.JLS8); return newAst.newExpressionStatement((Expression) ASTNode.copySubtree(newAst, assignExp)); }
public void testCopySubtree() { CalloutMappingDeclaration calloutDecl = (CalloutMappingDeclaration) _role.bodyDeclarations().get(7); List parameterMappings = calloutDecl.getParameterMappings(); ParameterMapping testObj = (ParameterMapping) parameterMappings.get(2); ParameterMapping clonedTestObject = (ParameterMapping) ASTNode.copySubtree(AST.newAST(AST.JLS4), testObj); boolean actual = testObj.subtreeMatch(new ASTMatcher(), clonedTestObject); assertTrue("Copy of subtree not correct", actual); }
private Example makeExample( MethodDeclaration node, Set<? extends Expression> envolvedInvocations, List<ApiMethod> envolvedApiMethods) { // Visitor responsável por realizar o slicing de programas SlicingStatementVisitor visitor = new SlicingStatementVisitor(node, new HashSet<ASTNode>(envolvedInvocations)); node.accept(visitor); Collection<Statement> relatedStatements = visitor.getSlicedStatements(); ASTNode newAST = ASTUtil.copyStatements(node.getBody(), relatedStatements, AST.newAST(AST.JLS3)); if (!relatedStatements.isEmpty()) { LOGGER.error("Some statements were not included!"); } if (newAST == null) { LOGGER.error("Slicing process failed for node "); // TODO Se AST retornada for nula é porque faltou incluir statement(s) return null; } else if (((Block) newAST).statements().isEmpty()) { LOGGER.error("Slicing process failed for node "); // TODO Se o Block retornado for vazio é porque faltou incluir statement(s) return null; } ASTUtil.removeEmptyBlocks((Block) newAST); // Adiciona declarações de variáveis que não foram encontradas no escopo do método // Para facilitar, tipos iguais são declarados no mesmo Statement Set<String> additionalDeclarationLines = new HashSet<String>(); Map<ITypeBinding, List<IVariableBinding>> typesMap = new HashMap<ITypeBinding, List<IVariableBinding>>(); for (IVariableBinding ivb : visitor.getUndiscoveredDeclarations()) { if (!typesMap.containsKey(ivb.getType())) { typesMap.put(ivb.getType(), new ArrayList<IVariableBinding>(2)); } typesMap.get(ivb.getType()).add(ivb); } for (ITypeBinding typeBinding : typesMap.keySet()) { List<IVariableBinding> variableBindings = typesMap.get(typeBinding); Stack<VariableDeclarationFragment> fragments = new Stack<VariableDeclarationFragment>(); for (IVariableBinding ivb : variableBindings) { VariableDeclarationFragment declarationFragment = newAST.getAST().newVariableDeclarationFragment(); declarationFragment.setName(newAST.getAST().newSimpleName(ivb.getName())); fragments.add(declarationFragment); } VariableDeclarationStatement statement = newAST.getAST().newVariableDeclarationStatement(fragments.pop()); while (!fragments.isEmpty()) { statement.fragments().add(fragments.pop()); } statement.setType(this.getType(typeBinding, newAST.getAST())); additionalDeclarationLines.add(statement.toString()); ((Block) newAST).statements().add(0, statement); } Example example = new Example(); example.setAttachment(this.attachmentMap.get(node.getRoot())); example.setApiMethods(new HashSet<ApiElement>(envolvedApiMethods)); example.setImports(visitor.getImports()); for (Expression seed : envolvedInvocations) { example.getSeeds().add(seed.toString()); } example.setSourceMethod(node.toString()); example.setAddedAt(new Date(System.currentTimeMillis())); try { IMethodBinding nodeBinding = node.resolveBinding(); if (!this.methodMap.containsKey(nodeBinding)) { ApiClass newApiClass = new ApiClass(nodeBinding.getDeclaringClass().getQualifiedName()); methodDeclarationHandler(node, newApiClass); } example.setSourceMethodCall(this.methodMap.get(nodeBinding).getFullName()); } catch (Exception e) { LOGGER.error(e); if (example.getSourceMethodCall() == null) { example.setSourceMethodCall("?"); } } String codeExample = newAST.toString(); for (String line : additionalDeclarationLines) { codeExample = codeExample.replace( line, line.replace("\n", "").concat(" ").concat("//initialized previously").concat("\n")); } // FIXME codeExample = codeExample.replaceAll("(\\{\n)(\\s+)(\\})", "$1 //do something \n$3"); try { example.setCodeExample(codeExample); example.setFormattedCodeExample(ASTUtil.codeFormatter(codeExample)); } catch (Exception e) { LOGGER.error(e); if (example.getFormattedCodeExample() == null) { example.setFormattedCodeExample(codeExample); } } // TODO Obter métricas do exemplo example .getMetrics() .put(ExampleMetric.LOC.name(), example.getFormattedCodeExample().split("\n").length - 1); example.getMetrics().put(ExampleMetric.ARGUMENTS.name(), visitor.getNumberOfArguments()); example .getMetrics() .put(ExampleMetric.DECISION_STATEMENTS.name(), visitor.getNumberOfDecisionStatements()); example.getMetrics().put(ExampleMetric.INVOCATIONS.name(), visitor.getNumberOfInvocations()); example .getMetrics() .put(ExampleMetric.NULL_ARGUMENTS.name(), visitor.getNumberOfNullArguments()); example .getMetrics() .put(ExampleMetric.PRIMITIVE_ARGUMENTS.name(), visitor.getNumberOfPrimitiveArguments()); example .getMetrics() .put(ExampleMetric.FIELD_ARGUMENTS.name(), visitor.getNumberOfFieldArguments()); example .getMetrics() .put( ExampleMetric.UNDISCOVERED_DECLARATIONS.name(), visitor.getNumberOfUndiscoveredDeclarations()); example .getMetrics() .put(ExampleMetric.UNHANDLED_EXCEPTIONS.name(), visitor.getNumberOfUnhandledExceptions()); return example; }
public AST newTree() { return AST.newAST(this.level.getValue()); }
// generate a variable declaration with an initializer specified by the given expression // e.g. given x.f(a,b) ==> int y = x.f(a,b); public static List<Statement> genVarDeclStatement(Expression exp) { List<Statement> result = new ArrayList<Statement>(); VariableDeclarationFragment fragment = AST.newAST(AST.JLS8).newVariableDeclarationFragment(); ExpressionStatement assignmentStmt = genAssignmentStatement(exp); // The type of the generated variable Type varType = AST.newAST(AST.JLS8).newWildcardType(); if (exp.resolveTypeBinding() != null) { if (exp.resolveTypeBinding().isPrimitive()) { switch (exp.resolveTypeBinding().getName()) { case "void": varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.VOID); break; case "int": varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.INT); break; case "char": varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.CHAR); break; case "long": varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.LONG); break; case "boolean": varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.BOOLEAN); break; case "float": varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.FLOAT); break; case "short": varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.SHORT); break; case "byte": varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.BYTE); break; case "double": varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.DOUBLE); break; } } else { // Option 1: only use the simplename /* SimpleName typeName = AST.newAST(AST.JLS8).newSimpleName(exp.resolveTypeBinding().getName()); AST tempAST = AST.newAST(AST.JLS8); varType = tempAST.newSimpleType((Name) ASTNode.copySubtree(tempAST, typeName)); */ varType = resolveQualifiedType(exp.resolveTypeBinding().getQualifiedName()); } } // Declaration Fragment fragment.setName( (SimpleName) ASTNode.copySubtree( fragment.getAST(), ((SimpleName) ((Assignment) assignmentStmt.getExpression()).getLeftHandSide()))); // fragment.setInitializer((Expression) ASTNode.copySubtree(fragment.getAST(), exp)); AST varDeclFragAST = AST.newAST(AST.JLS8); VariableDeclarationStatement decl = varDeclFragAST.newVariableDeclarationStatement( (VariableDeclarationFragment) ASTNode.copySubtree(varDeclFragAST, fragment)); decl.setType((Type) ASTNode.copySubtree(decl.getAST(), varType)); result.add(decl); // initializer is defined here as a separate statement Assignment assign = varDeclFragAST.newAssignment(); assign.setLeftHandSide((Expression) ASTNode.copySubtree(varDeclFragAST, fragment.getName())); assign.setRightHandSide((Expression) ASTNode.copySubtree(varDeclFragAST, exp)); ExpressionStatement assignStmt = varDeclFragAST.newExpressionStatement(assign); result.add(assignStmt); return result; }
private static Type resolveQualifiedType(String s) { if (s.equals("byte")) { return AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.BYTE); } if (s.equals("")) { return AST.newAST(AST.JLS8).newWildcardType(); } // It's a type parameter if (s.contains("<") && s.contains(">")) { // TODO: resolve type parameters String s0 = s.substring(0, s.indexOf("<")); Type hd = resolveQualifiedType(s0); AST tAST = AST.newAST(AST.JLS8); ParameterizedType pt = tAST.newParameterizedType((Type) ASTNode.copySubtree(tAST, hd)); for (String i : splitTypeArgs(s.substring(s.indexOf("<") + 1, s.lastIndexOf(">")))) { pt.typeArguments().add(ASTNode.copySubtree(tAST, resolveQualifiedType(i))); } return pt; } // It's an array type if (s.contains("[") && s.contains("]")) { String s0 = s.substring(0, s.indexOf("[")); Type hd = resolveQualifiedType(s0); AST tast = AST.newAST(AST.JLS8); ArrayType pt = tast.newArrayType((Type) ASTNode.copySubtree(tast, hd)); return pt; } if (!s.contains(".")) { AST ast = AST.newAST(AST.JLS8); if (s == null || s.equals("null")) { return ast.newSimpleType((Name) ASTNode.copySubtree(ast, genSimpleName("String"))); } switch (s) { case "void": return AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.VOID); case "int": return AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.INT); case "char": return AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.CHAR); case "long": return AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.LONG); case "boolean": return AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.BOOLEAN); case "float": return AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.FLOAT); case "short": return AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.SHORT); case "byte": return AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.BYTE); case "double": return AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.DOUBLE); } return ast.newSimpleType((Name) ASTNode.copySubtree(ast, genSimpleName(s))); } else { int last = s.lastIndexOf("."); AST ast = AST.newAST(AST.JLS8); String lastFrag = s.substring(last + 1); return ast.newQualifiedType( (Type) ASTNode.copySubtree(ast, resolveQualifiedType(s.substring(0, last))), (SimpleName) ASTNode.copySubtree(ast, genSimpleName(lastFrag))); } }
// generate a SimpleName node public static SimpleName genSimpleName(String s) { return AST.newAST(AST.JLS8).newSimpleName(s); }
// generate an empty block public static Block genBlock() { return AST.newAST(AST.JLS8).newBlock(); }
@SuppressWarnings("unchecked") @Before public void setUp() { manager = ModelManager.getInstance(); manager.clearModel(); AST ast2 = AST.newAST(AST.JLS3); CompilationUnit cu2 = ast2.newCompilationUnit(); PackageDeclaration pack2 = ast2.newPackageDeclaration(); pack2.setName(ast2.newName("be.ac.ua.test.otherpack")); cu2.setPackage(pack2); TypeDeclaration type2 = ast2.newTypeDeclaration(); type2.setName(ast2.newSimpleName("Foo")); cu2.types().add(type2); // created mock compilationunit containing package and class PackageRecorder prec2 = new PackageRecorder(pack2); prec2.storeChange(new Add()); // store the package addition ClassRecorder crec2 = new ClassRecorder(type2); declaredclassadd = new Add(); crec2.storeChange(declaredclassadd); AST ast = AST.newAST(AST.JLS3); CompilationUnit cu = ast.newCompilationUnit(); PackageDeclaration pack = ast.newPackageDeclaration(); pack.setName(ast.newName(packname)); cu.setPackage(pack); TypeDeclaration type = ast.newTypeDeclaration(); type.setName(ast.newSimpleName(classname)); cu.types().add(type); PackageRecorder prec = new PackageRecorder(pack); prec.storeChange(new Add()); // store the package addition ClassRecorder crec = new ClassRecorder(type); classadd = new Add(); crec.storeChange(classadd); // Class and package created and changes logged, now create the Field. VariableDeclarationFragment frag1 = ast.newVariableDeclarationFragment(); frag1.setName(ast.newSimpleName(intfieldname)); FieldDeclaration field = ast.newFieldDeclaration(frag1); field.setType(ast.newPrimitiveType(PrimitiveType.INT)); // field has type int type.bodyDeclarations().add(field); VariableDeclarationFragment frag2 = ast.newVariableDeclarationFragment(); frag2.setName(ast.newSimpleName(fieldname)); FieldDeclaration field2 = ast.newFieldDeclaration(frag2); field2.setType(ast.newSimpleType(ast.newName(declaredTypeName))); // field has type Foo type.bodyDeclarations().add(field2); VariableDeclarationFragment frag3 = ast.newVariableDeclarationFragment(); frag3.setName(ast.newSimpleName(field3Name)); FieldDeclaration field3 = ast.newFieldDeclaration(frag3); field3.setType(ast.newSimpleType(ast.newName("Foo"))); // field has type Foo type.bodyDeclarations().add(field3); ImportDeclaration imp = ast.newImportDeclaration(); imp.setName(ast.newName(declaredTypeName)); cu.imports().add(imp); // created mock compilationunit containing package and class recorder1 = new FieldRecorder(field); recorder2 = new FieldRecorder(field2); recorder3 = new FieldRecorder(field3); }