Java Code Examples for spoon.reflect.code.CtConstructorCall

The following examples show how to use spoon.reflect.code.CtConstructorCall. These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
@Test
public void testReferenceProcessor() throws Exception {
	final String[] args = {
			"-i", "src/test/resources/factory/",
			"-o", "target/spooned/"
	};

	final Launcher launcher = new Launcher();
	launcher.setArgs(args);
	launcher.run();

	final Factory factory = launcher.getFactory();
	final ProcessingManager processingManager = new QueueProcessingManager(factory);
	List<CtInterface> listFactoryItf = factory.getModel().getElements(new NamedElementFilter<>(CtInterface.class, "Factory"));
	assertThat(listFactoryItf.size(), is(1));

	final FactoryProcessor processor = new FactoryProcessor(listFactoryItf.get(0).getReference());
	processingManager.addProcessor(processor);

	List<CtConstructorCall> ctNewClasses = factory.getModel().getElements(new TypeFilter<>(CtConstructorCall.class));
	processingManager.process(ctNewClasses);

	// implicit constructor is also counted
	assertThat(processor.listWrongUses.size(), is(2));
}
 
Example 2
Source Project: coming   Source File: ConstructorAnalyzer.java    License: MIT License 6 votes vote down vote up
private void analyzeWhetherConstructorOftheclass (List<CtConstructorCall> constructorsaffected, Cntx<Object> context,
		CtClass parentclss) {
	
	 try {
		 for (CtConstructorCall conAffected : constructorsaffected) {
			
			boolean con5oftheclass = false;
			
			if (conAffected.getType()!=null && (conAffected.getType().getQualifiedName().endsWith(parentclss.getSimpleName()))) {
				con5oftheclass = true;
			}
			
			writeGroupedInfo(context, adjustIdentifyInJson(conAffected),
					CodeFeatures.CON5_Of_Class, 
					con5oftheclass, "FEATURES_CONSTRUCTOR");
		}
	} catch (Throwable e) {
		e.printStackTrace();
	}
}
 
Example 3
Source Project: coming   Source File: ConstructorAnalyzer.java    License: MIT License 6 votes vote down vote up
private void analyzeConstructorFeature_Extend (CtElement originalElement, Cntx<Object> context,
	CtClass parentClass, List<CtConstructorCall> allconstructorcallsFromClass, List<CtConstructorCall> constructorcallstostudy) {
	
	List<CtInvocation> emptyinvocationfromclass = new ArrayList<CtInvocation>();
	List<CtInvocation> emptyinvocationunderstudy = new ArrayList<CtInvocation>();

	for(CtConstructorCall constructorcallAffected : constructorcallstostudy) {
           
           boolean[] constructorcallfeature91012 = analyze_SamerMethodWithGuardOrTrywrap(originalElement, parentClass, emptyinvocationfromclass,
           		emptyinvocationunderstudy, allconstructorcallsFromClass, Arrays.asList(constructorcallAffected));

           if(constructorcallfeature91012 != null) {
			
           	writeGroupedInfo(context, adjustIdentifyInJson(constructorcallAffected), CodeFeatures.CON9_METHOD_CALL_WITH_NORMAL_GUARD, 
           			constructorcallfeature91012[0], "FEATURES_CONSTRUCTOR");
			
           	writeGroupedInfo(context, adjustIdentifyInJson(constructorcallAffected), CodeFeatures.CON10_METHOD_CALL_WITH_NULL_GUARD, 
           			constructorcallfeature91012[1], "FEATURES_CONSTRUCTOR");
           	
           	writeGroupedInfo(context, adjustIdentifyInJson(constructorcallAffected), CodeFeatures.CON12_METHOD_CALL_WITH_TRY_CATCH, 
           			constructorcallfeature91012[2], "FEATURES_CONSTRUCTOR");
		}         
	}	
}
 
Example 4
Source Project: coming   Source File: MethodAnalyzer.java    License: MIT License 6 votes vote down vote up
private void analyzeMethodFeature_Extend (CtElement originalElement, Cntx<Object> context,
		CtClass parentClass, List<CtInvocation> invocationsFromClass, List<CtInvocation> invocations) {
	
	List<CtConstructorCall> emptyconstructorcallfromclass = new ArrayList<CtConstructorCall>();
	List<CtConstructorCall> emptyconstructorcallunderstudy = new ArrayList<CtConstructorCall>();

	for(CtInvocation invocationAffected : invocations) {
           
           boolean[] methdofeature91012 = analyze_SamerMethodWithGuardOrTrywrap(originalElement, parentClass, invocationsFromClass,
           		Arrays.asList(invocationAffected), emptyconstructorcallfromclass, emptyconstructorcallunderstudy);

           if(methdofeature91012 != null) {
			
           	writeGroupedInfo(context, adjustIdentifyInJson(invocationAffected), CodeFeatures.M9_METHOD_CALL_WITH_NORMAL_GUARD, 
           			methdofeature91012[0], "FEATURES_METHODS");
			
           	writeGroupedInfo(context, adjustIdentifyInJson(invocationAffected), CodeFeatures.M10_METHOD_CALL_WITH_NULL_GUARD, 
           			methdofeature91012[1], "FEATURES_METHODS");
           	
           	writeGroupedInfo(context, adjustIdentifyInJson(invocationAffected), CodeFeatures.M12_METHOD_CALL_WITH_TRY_CATCH, 
           			methdofeature91012[2], "FEATURES_METHODS");
		}         
	}	
}
 
Example 5
@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public <T> void visitCtConstructorCall(CtConstructorCall<T> ctConstructorCall) {
	super.visitCtConstructorCall(ctConstructorCall);
	
	String type = ctConstructorCall.getType().getQualifiedName();
	List<CtExpression<?>>  argumentlist = ctConstructorCall.getArguments();
	List<String> orig = resolveTypes(argumentlist);

	CtClass classname = parser.getClassMap().get(type); 
	
	if(classname!=null) {
		Set<CtConstructor<T>> constructors=classname.getConstructors();
           for(CtConstructor constructor:constructors) {
           	List<CtParameter> paramlist=constructor.getParameters();
           	List<String> target=resolveParams(paramlist);
           	transformOneMethod(orig,target,ctConstructorCall);
           }
	} else {
		List<Class[]> params = parser.fetchMethods(type, type);
		for (Class[] p : params)
			transformOneConstructor(orig, ctConstructorCall, p);
	}
}
 
Example 6
Source Project: astor   Source File: TransformStrategy.java    License: GNU General Public License v2.0 6 votes vote down vote up
@Override
public <T> void visitCtConstructorCall(CtConstructorCall<T> ctConstructorCall) {
	super.visitCtConstructorCall(ctConstructorCall);

	List<CtExpression<?>>  argumentlist = ctConstructorCall.getArguments();
	for (int i = 0; i < argumentlist.size(); i++) {
		@SuppressWarnings("rawtypes")
		CtExpression p = argumentlist.get(i);
		if (candidates.containsKey(p)) {
			argumentlist.set(i, candidates.get(p));
		//	ctConstructorCall.setArguments(argumentlist);
			saveSketchAndSynthesize();
			argumentlist.set(i, p);
			resoreDiskFile();
		//	ctConstructorCall.setArguments(argumentlist);
		}
	}
}
 
Example 7
@Override
public void process(CtStatement element) {

	if (element instanceof CtIf) {
		add(((CtIf) element).getCondition());
	} else if (element instanceof CtFor) {
		add(((CtFor) element).getExpression());
	} else if (element instanceof CtWhile) {
		add(((CtWhile) element).getLoopingExpression());
	} else if (element instanceof CtDo) {
		add(((CtDo) element).getLoopingExpression());
	} else if (element instanceof CtThrow) {
		add(((CtThrow) element).getThrownExpression());
	} else if (element instanceof CtInvocation && (element.getParent() instanceof CtBlock)) {
		add(element);
	} else if (element instanceof CtAssignment || element instanceof CtConstructorCall
			|| element instanceof CtCFlowBreak || element instanceof CtLocalVariable) {
		add(element);
	}

}
 
Example 8
public void process(CtConstructorCall<?> newClass) {
	// skip factory creation
	if (newClass.getExecutable().getDeclaringType().isSubtypeOf(getFactoryType()))
		return;
	// skip creations in factories
	if (newClass.getParent(CtClass.class).isSubtypeOf(getFactoryType()))
		return;
	// only report for types created by the factory
	for (CtTypeReference<?> t : getCreatedTypes()) {
		if (newClass.getType().isSubtypeOf(t)) {
			this.listWrongUses.add(newClass);
		}
	}

}
 
Example 9
@Override
public void process(CtMethod method) {
    final Factory factory = method.getFactory();

    CtBlock methodBody = method.getBody();

    List<CtComment> bodyComments = new ArrayList<>();

    ArrayList<CtStatement> ctStatements = new ArrayList<>(methodBody.getStatements());
    for (CtStatement ctStatement : ctStatements) {
        String statement = ctStatement.toString();
        bodyComments.add(factory.createInlineComment(statement));
        methodBody.removeStatement(ctStatement);
    }

    CtClass<? extends Throwable> myExceptionClass = factory.Class().get(EXCEPTION_FQN);
    CtConstructorCall<? extends Throwable> myNewException = factory.createConstructorCall(myExceptionClass.getReference());

    CtThrow throwMyException = factory.createThrow();
    throwMyException.setThrownExpression(myNewException);
    methodBody.addStatement(throwMyException);

    bodyComments.add(factory.createInlineComment("FIXME: The private API type should never be return in a public API."));

    for (CtComment bodyComment : bodyComments) {
        throwMyException.addComment(bodyComment);
    }
}
 
Example 10
Source Project: coming   Source File: VariableAnalyzer.java    License: MIT License 5 votes vote down vote up
private int[] argumentDiff(List<CtElement> argumentsoriginal, List<CtElement> argumentsother, CtVariableAccess varaccess) {
	
	int numberdiffargument =0;
	int numberdiffvarreplacebyvar =0;
	int numberdiffvarreplacebymethod =0;
	
	for(int index=0; index<argumentsoriginal.size(); index++) {
		
		CtElement original = argumentsoriginal.get(index);
		CtElement other = argumentsother.get(index);
		
		if(original.equals(other) || original.toString().equals(other.toString())) {
			// same
		} else {
			numberdiffargument+=1;
			if(original instanceof CtVariableAccess && original.equals(varaccess)) {
				if(other instanceof CtVariableAccess)
					numberdiffvarreplacebyvar+=1;
				else if(other instanceof CtInvocation || other instanceof CtConstructorCall)
					numberdiffvarreplacebymethod+=1;
				else {
					// do nothing
				}
			}
		}
	}

	int diffarray[]=new int[3];
	diffarray[0]=numberdiffargument;
	diffarray[1]=numberdiffvarreplacebyvar;
	diffarray[2]=numberdiffvarreplacebymethod;

       return diffarray;
}
 
Example 11
Source Project: coming   Source File: MethodAnalyzer.java    License: MIT License 5 votes vote down vote up
private int[] argumentDiffMethod(List<CtElement> argumentsoriginal, List<CtElement> argumentsother, 
	   CtInvocation invocationaccess) {
	
	int numberdiffargument =0;
	int numberdiffmethodreplacebyvar =0;
	int numberdiffmethodreplacebymethod =0;
	
	for(int index=0; index<argumentsoriginal.size(); index++) {
		
		CtElement original = argumentsoriginal.get(index);
		CtElement other = argumentsother.get(index);
		
		if(original.equals(other) || original.toString().equals(other.toString())) {
			// same
		} else {
			numberdiffargument+=1;
			if(original instanceof CtInvocation && original.equals(invocationaccess)) {
				if(other instanceof CtVariableAccess)
					numberdiffmethodreplacebyvar+=1;
				else if(other instanceof CtInvocation || other instanceof CtConstructorCall)
					numberdiffmethodreplacebymethod+=1;
				else {
					// do nothing
				}
			}
		}
	}

	int diffarray[]=new int[3];
	diffarray[0]=numberdiffargument;
	diffarray[1]=numberdiffmethodreplacebyvar;
	diffarray[2]=numberdiffmethodreplacebymethod;

      return diffarray;
}
 
Example 12
Source Project: coming   Source File: CodeElementInfo.java    License: MIT License 5 votes vote down vote up
private void setConstructorcallsFromClass() {

		if (parentClass != null)
			constructorcallsFromClass = parentClass.getElements(e -> (e instanceof CtConstructorCall)).stream()
					.map(CtConstructorCall.class::cast).collect(Collectors.toList());
		else
			constructorcallsFromClass = null;
	}
 
Example 13
Source Project: coming   Source File: CodeElementInfo.java    License: MIT License 5 votes vote down vote up
private void setConstructorcalls() {
	if (elementToStudy != null)
		constructorcalls = elementToStudy.getElements(e -> (e instanceof CtConstructorCall)).stream()
				.map(CtConstructorCall.class::cast).collect(Collectors.toList());
	else
		constructorcalls = null;
}
 
Example 14
Source Project: astor   Source File: InsertBeforeOp.java    License: GNU General Public License v2.0 5 votes vote down vote up
@Override
public boolean canBeAppliedToPoint(ModificationPoint point) {

	boolean apply = super.canBeAppliedToPoint(point);
	if (!apply)
		return apply;

	// do not insert after a return
	if (point.getCodeElement() instanceof CtConstructorCall) {
		return false;
	}

	// Otherwise, accept the element
	return true;
}
 
Example 15
Source Project: astor   Source File: TransformStrategy.java    License: GNU General Public License v2.0 5 votes vote down vote up
@SuppressWarnings({ "unchecked", "rawtypes" })
public List<String> transform () {
	CtStatement targetStmt = (CtStatement) this.modificationPoint.getCodeElement();
	if (targetStmt instanceof CtInvocation)
		this.visitCtInvocation((CtInvocation) targetStmt);
	else if (targetStmt instanceof CtConstructorCall)
		this.visitCtConstructorCall((CtConstructorCall) targetStmt);
	else if (targetStmt instanceof CtIf)
		this.visitCtIf ((CtIf)targetStmt);
	else if (targetStmt instanceof CtReturn)
		this.visitCtReturn((CtReturn) targetStmt);
	else if (targetStmt instanceof CtSwitch)
		this.visitCtSwitch((CtSwitch) targetStmt);
	else if (targetStmt instanceof CtCase)
		this.visitCtCase((CtCase) targetStmt);
	else if (targetStmt instanceof CtAssignment)
		this.visitCtAssignment((CtAssignment) targetStmt);
	else if (targetStmt instanceof CtAssert)
		this.visitCtAssert((CtAssert) targetStmt);
	else if (targetStmt instanceof CtFor)
		this.visitCtFor((CtFor) targetStmt);
	else if (targetStmt instanceof CtForEach)
		this.visitCtForEach((CtForEach) targetStmt);
	else if (targetStmt instanceof CtWhile)
		this.visitCtWhile((CtWhile) targetStmt);
	else if (targetStmt instanceof CtUnaryOperator)
		this.visitCtUnaryOperator((CtUnaryOperator) targetStmt);
	else if (targetStmt instanceof CtSynchronized)
		this.visitCtSynchronized((CtSynchronized) targetStmt);

	return list;
}
 
Example 16
@Override
public boolean canBeAppliedToPoint(ModificationPoint point) {

	if (!(point.getCodeElement() instanceof CtStatement))
		return false;

	// do not insert after a return
	if (point.getCodeElement() instanceof CtConstructorCall || point.getCodeElement() instanceof CtReturn) {
		return false;
	}

	// Otherwise, accept the element
	return true;
}
 
Example 17
@Override
public boolean canBeAppliedToPoint(ModificationPoint point) {

	if (!(point.getCodeElement() instanceof CtStatement))
		return false;

	// do not insert after a return
	if (point.getCodeElement() instanceof CtConstructorCall || point.getCodeElement() instanceof CtReturn) {
		return false;
	}

	// Otherwise, accept the element
	return true;
}
 
Example 18
Source Project: astor   Source File: InvocationResolver.java    License: GNU General Public License v2.0 5 votes vote down vote up
/**
 * Return all variables related to the element passed as argument
 * 
 * @param element
 * @return
 */
@SuppressWarnings("rawtypes")
public static List<CtAbstractInvocation> collectInvocation(CtElement element, boolean duplicates) {
	List<CtAbstractInvocation> varaccess = new ArrayList<>();

	CtScanner sc = new CtScanner() {

		public void add(CtAbstractInvocation e) {
			if (duplicates || !varaccess.contains(e))
				varaccess.add(e);
		}

		@Override
		public <T> void visitCtInvocation(CtInvocation<T> invocation) {
			super.visitCtInvocation(invocation);
			add(invocation);
		}

		@Override
		public <T> void visitCtConstructorCall(CtConstructorCall<T> ctConstructorCall) {
			super.visitCtConstructorCall(ctConstructorCall);
			add(ctConstructorCall);
		}

	};

	sc.scan(element);

	return varaccess;

}
 
Example 19
Source Project: astor   Source File: InvocationResolver.java    License: GNU General Public License v2.0 5 votes vote down vote up
@SuppressWarnings("rawtypes")
public static InvocationMatching mapImplicitInvocation(CtClass ctClassMP, CtAbstractInvocation inv0) {
	if (inv0 instanceof CtInvocation) {
		CtInvocation invocation0 = (CtInvocation) inv0;

		CtExpression tpr = invocation0.getTarget();
		if (tpr instanceof CtThisAccess) {
			CtThisAccess<?> targetthis = (CtThisAccess) tpr;
			CtTypeReference tpref = targetthis.getType();
			if (ctClassMP.isSubtypeOf(tpref))
				return InvocationMatching.TARGET_SAME_TYPE;
			else if (chechSignatures(ctClassMP.getAllExecutables(), invocation0.getExecutable(), false)) {
				return InvocationMatching.SAME_SIGNATURE_FROM_DIFF_TYPE;
			} else {
				log.debug("Signature " + invocation0.getExecutable().getSignature());
				log.debug(
						"Not compatible: " + ctClassMP.getQualifiedName() + " with " + (tpref.getQualifiedName()));
				return InvocationMatching.TARGET_INCOMPATIBLE;
			}
		} else {
			log.debug("Explicit target " + tpr);
			return InvocationMatching.TARGET_IS_VARIABLE;
		}
	} else {

		if (inv0 instanceof CtConstructorCall) {
			return InvocationMatching.CONTRUCTOR;

		}

		return InvocationMatching.OTHER;
	}

}
 
Example 20
Source Project: gumtree-spoon-ast-diff   Source File: AstComparatorTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void test_t_211903() throws Exception {
	AstComparator diff = new AstComparator();
	// meld src/test/resources/examples/t_211903/left_MemberFilePersister_1.4.java
	// src/test/resources/examples/t_211903/right_MemberFilePersister_1.5.java
	File fl = new File("src/test/resources/examples/t_211903/left_MemberFilePersister_1.4.java");
	File fr = new File("src/test/resources/examples/t_211903/right_MemberFilePersister_1.5.java");
	Diff result = diff.compare(fl, fr);

	// result.debugInformation();

	CtElement ancestor = result.commonAncestor();
	assertTrue(ancestor instanceof CtConstructorCall);
	assertEquals(88, ancestor.getPosition().getLine());

	List<Operation> actions = result.getRootOperations();
	// result.debugInformation();
	assertTrue(
			result.containsOperation(OperationKind.Update, "ConstructorCall", "java.io.FileReader(java.io.File)"));
	assertTrue(result.containsOperation(OperationKind.Insert, "ConstructorCall",
			"java.io.InputStreamReader(java.io.InputStream,java.lang.String)"));

	// additional checks on low-level actions
	assertTrue(result.containsOperations(result.getAllOperations(), OperationKind.Insert, "Literal", "\"UTF-8\""));

	// the change is in the local variable declaration
	CtElement elem = actions.get(0).getNode();
	assertNotNull(elem);
	assertNotNull(elem.getParent(CtLocalVariable.class));
}
 
Example 21
@SuppressWarnings("all")
@Test
public void main() {
    MavenLauncher launcher = new MavenLauncher(
            "./src/test/resources/project/",
            MavenLauncher.SOURCE_TYPE.APP_SOURCE);

    CtModel model = launcher.buildModel();
    List<CtMethod> methodList = model.
            filterChildren(new NamedElementFilter<CtPackage>(CtPackage.class, "ow2con")).
            filterChildren(new NamedElementFilter<CtPackage>(CtPackage.class, "publicapi")).
            filterChildren(new TypeFilter<CtMethod>(CtMethod.class)).
            filterChildren(new Filter<CtMethod>() {
                @Override
                public boolean matches(CtMethod element) {
                    boolean isPublic = element.isPublic();
                    CtTypeReference returnType = element.getType();
                    String privateApiPackage = "ow2con.privateapi";
                    boolean isTypeFromPrivateApi = returnType.getQualifiedName().contains(privateApiPackage);
                    return isPublic && isTypeFromPrivateApi;
                }
            }).list();

    Factory factory = launcher.getFactory();
    CtClass<? extends Throwable> exceptionClass = factory.createClass("ow2con.PrivateAPIException");
    CtConstructorCall<? extends Throwable> exceptionInstance = factory.createConstructorCall(exceptionClass.getReference());

    for (CtMethod method : methodList) {
        CtBlock methodBody = method.getBody();
        List<CtComment> bodyComments = new ArrayList<>();

        ArrayList<CtStatement> ctStatements = new ArrayList<>(methodBody.getStatements());

        for (CtStatement ctStatement : ctStatements) {
            String statement = ctStatement.toString();
            CtComment statementAsComment = factory.createInlineComment(statement);
            bodyComments.add(statementAsComment);
            methodBody.removeStatement(ctStatement);
        }

        CtThrow throwMyException = factory.createThrow();
        CtConstructorCall<? extends Throwable> constructorCall = exceptionInstance.clone();
        throwMyException.setThrownExpression(constructorCall);
        methodBody.addStatement(throwMyException);

        bodyComments.add(
                factory.createInlineComment(
                "FIXME: The private API type should never be return in a public API."
                )
        );

        for (CtComment bodyComment : bodyComments) {
            throwMyException.addComment(bodyComment);
        }
    }

    Environment environment = launcher.getEnvironment();
    environment.setCommentEnabled(true);
    environment.setAutoImports(true);
    // the transformation must produce compilable code
    environment.setShouldCompile(true);
    launcher.prettyprint();

    // look in folder spooned/ow2con/publicapi/ the transformed code
}
 
Example 22
Source Project: coming   Source File: ExpressionAnalyzer.java    License: MIT License 4 votes vote down vote up
private void analyzeExpressionFeatures(List<CtExpression> expressionsToStudy, CtElement originalElement, Cntx<Object> context,
		CtClass parentClass, List<CtStatement> allstatementsinclass, List<CtVariable> varsInScope, 
		List allMethodsFromClass, List<CtInvocation> invocationsFromClass, List<CtConstructorCall> constructorcallsFromClass) {

	for(int expressionindex=0; expressionindex<expressionsToStudy.size(); expressionindex++) {
		
		CtExpression specificexpression = expressionsToStudy.get(expressionindex);
		
		List<CtVariableAccess> varsAffected = VariableResolver.collectVariableAccess(specificexpression, false);

		// Get all invocations inside the faulty element
		List<CtInvocation> invocations = specificexpression.getElements(e -> (e instanceof CtInvocation)).stream()
				.map(CtInvocation.class::cast).collect(Collectors.toList());
		
		List<CtConstructorCall> constructorcall = specificexpression.getElements(e -> (e instanceof CtConstructorCall)).stream()
				.map(CtConstructorCall.class::cast).collect(Collectors.toList());
		
		writeGroupedInfo(context, "expression_"+Integer.toString(expressionindex), CodeFeatures.E1_LOCAL_VAR_NOT_USED, 
				analyze_AffectedVariablesUsed (varsAffected, originalElement, allstatementsinclass), 
				"FEATURES_EXPRESSION");
		
		writeGroupedInfo(context, "expression_"+Integer.toString(expressionindex), CodeFeatures.E1_LOCAL_VAR_NOT_ASSIGNED, 
				analyze_AffectedAssigned (varsAffected, originalElement), 
				"FEATURES_EXPRESSION");
		
		boolean[] expressionfeatures = analyze_SametypewithGuard(varsAffected, originalElement, parentClass, allstatementsinclass);

		if(expressionfeatures != null) {
			
			writeGroupedInfo(context, "expression_"+Integer.toString(expressionindex), CodeFeatures.E2_SIMILAR_OBJECT_TYPE_WITH_NORMAL_GUARD, 
					expressionfeatures[0], "FEATURES_EXPRESSION");
			
			writeGroupedInfo(context, "expression_"+Integer.toString(expressionindex), CodeFeatures.E5_SIMILAR_PRIMITIVE_TYPE_WITH_NORMAL_GUARD, 
					expressionfeatures[1], "FEATURES_EXPRESSION");
			
			writeGroupedInfo(context, "expression_"+Integer.toString(expressionindex), CodeFeatures.E2_SIMILAR_OBJECT_TYPE_WITH_NULL_GUARD, 
					expressionfeatures[2], "FEATURES_EXPRESSION");
			
			writeGroupedInfo(context, "expression_"+Integer.toString(expressionindex), CodeFeatures.E5_SIMILAR_PRIMITIVE_TYPE_WITH_NULL_GUARD, 
					expressionfeatures[3], "FEATURES_EXPRESSION");
		}
		
		writeGroupedInfo(context, "expression_"+Integer.toString(expressionindex), CodeFeatures.E4_Field_NOT_USED, 
				analyze_AffectedFielfs(varsAffected, originalElement, parentClass), 
				"FEATURES_EXPRESSION");
		
		writeGroupedInfo(context, "expression_"+Integer.toString(expressionindex), CodeFeatures.E4_Field_NOT_ASSIGNED, 
				analyze_AffectedFieldAssigned(varsAffected, originalElement, parentClass), 
				"FEATURES_EXPRESSION");
		
		boolean[] expressionvalueS7S8 = analyze_AffectedObjectLastAppear(varsAffected, originalElement, allstatementsinclass);

           if(expressionvalueS7S8 != null) {
			
           	writeGroupedInfo(context, "expression_"+Integer.toString(expressionindex), CodeFeatures.E7_OBJECT_USED_IN_ASSIGNMENT, 
					expressionvalueS7S8[0], "FEATURES_EXPRESSION");
			
           	writeGroupedInfo(context, "expression_"+Integer.toString(expressionindex), CodeFeatures.E8_PRIMITIVE_USED_IN_ASSIGNMENT, 
					expressionvalueS7S8[1], "FEATURES_EXPRESSION");
		}
           
           boolean[] expressionvalueS9S10 = analyze_SamerMethodWithGuardOrTrywrap(originalElement, parentClass, invocationsFromClass, invocations,
           		constructorcallsFromClass, constructorcall);

           if(expressionvalueS9S10 != null) {
			
           	writeGroupedInfo(context, "expression_"+Integer.toString(expressionindex), CodeFeatures.E9_METHOD_CALL_WITH_NORMAL_GUARD, 
					expressionvalueS9S10[0], "FEATURES_EXPRESSION");
			
           	writeGroupedInfo(context, "expression_"+Integer.toString(expressionindex), CodeFeatures.E10_METHOD_CALL_WITH_NULL_GUARD, 
					expressionvalueS9S10[1], "FEATURES_EXPRESSION");
		}     
           
           writeGroupedInfo(context, "expression_"+Integer.toString(expressionindex), CodeFeatures.E1_RETURN_PRIMITIVE, 
           		getExpressionType(specificexpression), "FEATURES_EXPRESSION");
           
           boolean[] expressionvalueType = analyzeExpression(specificexpression, context, allMethodsFromClass, invocationsFromClass, parentClass);

           if(expressionvalueType != null) {
			
           	writeGroupedInfo(context, "expression_"+Integer.toString(expressionindex), CodeFeatures.E2_COMPATIBLE_INVOCATION_PAREMETER_RETURN, 
					expressionvalueType[0], "FEATURES_EXPRESSION");
			
           	writeGroupedInfo(context, "expression_"+Integer.toString(expressionindex), CodeFeatures.E3_COMPATIBLE_INVOCATION_PAREMETER, 
					expressionvalueType[1], "FEATURES_EXPRESSION");
		}    
	}	
}
 
Example 23
Source Project: coming   Source File: AbstractCodeAnalyzer.java    License: MIT License 4 votes vote down vote up
public String getSimplenameForConstructorCall(CtConstructorCall call) {

		String[] namespace = call.getType().getQualifiedName().split("\\(")[0].split("\\.");
		String constructorname = namespace[namespace.length - 1];
		return constructorname;
	}
 
Example 24
Source Project: coming   Source File: ConstructorAnalyzer.java    License: MIT License 4 votes vote down vote up
private void analyzeVarConstructorArgumentPrimitive (List<CtConstructorCall> constructorsaffected, Cntx<Object> context) {
	
	 try {
		 for (CtConstructorCall conAffected : constructorsaffected) {
			
			boolean Con6ArgumentHasPrimitive = false;
			
			List<CtExpression> invocationArguments = conAffected.getArguments();
			
			for(int index=0; index<invocationArguments.size(); index++ ) {
				
				CtExpression certainexpression=invocationArguments.get(index);
				
				if (certainexpression.getType()!=null && (certainexpression.getType().isPrimitive() || 
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("string") ||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("long") || 
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("list") ||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().indexOf("string")!=-1 ||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("boolean") ||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("double") ||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("byte")||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("short")||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("float") ||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("chart") ||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("character") ||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("integer")||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("string[]") ||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("long[]") || 
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("boolean[]") ||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("double[]") ||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("byte[]")||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("short[]")||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("float[]") ||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("chart[]") ||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("character[]") ||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().endsWith("integer[]") ||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().startsWith("java.util.") ||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().startsWith("java.nio.") ||
						certainexpression.getType().getQualifiedName().toString().toLowerCase().startsWith("java.io."))) {
					
					Con6ArgumentHasPrimitive = true;
					break;
				}
			}
			
			writeGroupedInfo(context, adjustIdentifyInJson(conAffected),
					CodeFeatures.CON6_Argument_Has_Primitive, 
					Con6ArgumentHasPrimitive, "FEATURES_CONSTRUCTOR");
		}
	} catch (Throwable e) {
		e.printStackTrace();
	}
}
 
Example 25
Source Project: coming   Source File: ConstructorAnalyzer.java    License: MIT License 4 votes vote down vote up
private void analyzeWhetherConstructorreturnprimitive (List<CtConstructorCall> constructorsaffected, Cntx<Object> context) {
	
	 try {
		 for (CtConstructorCall conAffected : constructorsaffected) {
			
			boolean con4returnprimitive = false;
			
			if (conAffected.getType()!=null && (conAffected.getType().isPrimitive() || 
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("string") ||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("list") ||
					conAffected.getType().getQualifiedName().toString().toLowerCase().indexOf("string")!=-1 ||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("long") || 
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("boolean") ||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("double") ||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("byte")||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("short")||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("float") ||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("chart") ||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("character") ||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("integer")||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("string[]") ||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("long[]") || 
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("boolean[]") ||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("double[]") ||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("byte[]")||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("short[]")||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("float[]") ||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("chart[]") ||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("character[]") ||
					conAffected.getType().getQualifiedName().toString().toLowerCase().endsWith("integer[]") ||
					conAffected.getType().getQualifiedName().toString().toLowerCase().startsWith("java.util.") ||
					conAffected.getType().getQualifiedName().toString().toLowerCase().startsWith("java.nio.") ||
					conAffected.getType().getQualifiedName().toString().toLowerCase().startsWith("java.io."))) {
				con4returnprimitive = true;
			}
			
			writeGroupedInfo(context, adjustIdentifyInJson(conAffected),
					CodeFeatures.CON4_Return_Primitive, 
					con4returnprimitive, "FEATURES_CONSTRUCTOR");
		}
	} catch (Throwable e) {
		e.printStackTrace();
	}
}
 
Example 26
Source Project: coming   Source File: ConstructorAnalyzer.java    License: MIT License 4 votes vote down vote up
private void analyzeCon1_ConstructorOverload(CtElement element, Cntx<Object> context, CtClass parentClass,
		 List<CtConstructorCall> constructorcalls) {
	
	try {
		for (CtConstructorCall constructorcall : constructorcalls) {

			boolean con1SpecificHasSameName = false;
			
			List<CtConstructor> allconstructorsinclass = new ArrayList();
			if(parentClass!=null)
			     allconstructorsinclass = parentClass.getElements(new TypeFilter<>(CtConstructor.class));

			for (CtConstructor certainconstructorinclass : allconstructorsinclass) {

					CtConstructor anotherConstructor = (CtConstructor) certainconstructorinclass;
					// Ignoring if it's the same
					if (anotherConstructor == null || anotherConstructor.getSignature().
							equals(constructorcall.getExecutable().getSignature()))
						continue;

					if (anotherConstructor.getSimpleName().equals(getSimplenameForConstructorCall(constructorcall))) {
						// It's override
						con1SpecificHasSameName = true;
						break;
					}
			}
			
			List<CtConstructorCall> allconstructorcallsinclass = new ArrayList();

			if(parentClass!=null)
			     allconstructorcallsinclass = parentClass.getElements(new TypeFilter<>(CtConstructorCall.class));

		    if(!con1SpecificHasSameName) {
		    	
		    	for (CtConstructorCall certainconstructorcallinclass : allconstructorcallsinclass) {

		    		CtConstructorCall anotherConstructorCall = (CtConstructorCall) certainconstructorcallinclass;
					if (anotherConstructorCall == null || anotherConstructorCall.getExecutable().getSignature().
							equals(constructorcall.getExecutable().getSignature()))
						continue;

					if (getSimplenameForConstructorCall(anotherConstructorCall).equals(getSimplenameForConstructorCall(constructorcall))) {
						con1SpecificHasSameName = true;
						break;
					}
			    }
		    }
		    
		    writeGroupedInfo(context, adjustIdentifyInJson(constructorcall), CodeFeatures.CON1_OVERLOADED_CONSTRUCTOR,
		    		con1SpecificHasSameName, "FEATURES_CONSTRUCTOR");
		} 		
	} catch (Throwable e) {
		e.printStackTrace();
	}
}
 
Example 27
Source Project: gumtree-spoon-ast-diff   Source File: LabelFinder.java    License: Apache License 2.0 4 votes vote down vote up
@Override
public <T> void visitCtConstructorCall(CtConstructorCall<T> ctConstructorCall) {
	if (ctConstructorCall.getExecutable() != null) {
		label = ctConstructorCall.getExecutable().getSignature();
	}
}
 
Example 28
Source Project: coming   Source File: CodeElementInfo.java    License: MIT License 2 votes vote down vote up
private List<CtConstructorCall> getConstructorcallsFromClass() {

		return this.constructorcallsFromClass;
	}
 
Example 29
Source Project: coming   Source File: CodeElementInfo.java    License: MIT License 2 votes vote down vote up
private List<CtConstructorCall> getConstructorcalls() {

		return this.constructorcalls;
	}