Fix type of constructor calls in noclasspathmode

src/main/java/spoon/NoClasspathWorkaround.java

@@ -0,0 +1,23 @@
+/*
+ * SPDX-License-Identifier: (MIT OR CECILL-C)
+ *
+ * Copyright (C) 2006-2019 INRIA and contributors
+ *
+ * Spoon is available either under the terms of the MIT License (see LICENSE-MIT.txt) of the Cecill-C License (see LICENSE-CECILL-C.txt). You as the user are entitled to choose the terms under which to adopt Spoon.
+ */
+package spoon;
+
+/**
+ * This annotation is used to mark a workaround for the lack of a correct classpath so called noclasspathmode.
+ * <p>
+ * Workarounds for missing informations are marked with this annotation. These methods are not part of the Spoon API and best effort.
+ * With any new jdt version the workaround can be removed or no longer working.
+ */
+public @interface NoClasspathWorkaround {
+	/**
+	 * The reason why this workaround is needed. This is used for documentation purposes.
+	 * A link to the originale issue is sufficient.
+	 * @return  the reason why this workaround is needed
+	 */
+	String reason();
+}

src/main/java/spoon/experimental/NoClasspathWorkaround.java

@@ -0,0 +1,28 @@
+/*
+ * SPDX-License-Identifier: (MIT OR CECILL-C)
+ *
+ * Copyright (C) 2006-2019 INRIA and contributors
+ *
+ * Spoon is available either under the terms of the MIT License (see LICENSE-MIT.txt) of the Cecill-C License (see LICENSE-CECILL-C.txt). You as the user are entitled to choose the terms under which to adopt Spoon.
+ */
+package spoon.experimental;
+
+import spoon.support.Experimental;
+import spoon.support.Internal;
+
+/**
+ * This annotation is used to mark a workaround for the lack of a correct classpath so called noclasspathmode.
+ * <p>
+ * Workarounds for missing informations are marked with this annotation. These methods are not part of the Spoon API and best effort.
+ * With any new jdt version the workaround can be removed or no longer working.
+ */
+@Experimental
+@Internal
+public @interface NoClasspathWorkaround {
+	/**
+	 * The reason why this workaround is needed. This is used for documentation purposes.
+	 * A link to the originale issue is sufficient.
+	 * @return  the reason why this workaround is needed
+	 */
+	String reason();
+}

src/main/java/spoon/support/compiler/jdt/ReferenceBuilder.java

@@ -61,6 +61,7 @@
 import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;
 import org.eclipse.jdt.internal.compiler.lookup.VoidTypeBinding;
 import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding;
+import spoon.NoClasspathWorkaround;
 import spoon.reflect.code.CtLambda;
 import spoon.reflect.declaration.CtModule;
 import spoon.reflect.declaration.CtPackage;
@@ -449,12 +450,17 @@ <T> CtExecutableReference<T> getExecutableReference(AllocationExpression allocat
 		CtExecutableReference<T> ref;
 		if (allocationExpression.binding != null) {
 			ref = getExecutableReference(allocationExpression.binding);
+			// in some cases the binding is not null but points wrong to object type see #4643
+			if (isIncorrectlyBoundExecutableInNoClasspath(ref, allocationExpression)) {
+				adjustExecutableAccordingToResolvedType(ref, allocationExpression);
+			}
 		} else {
 			ref = jdtTreeBuilder.getFactory().Core().createExecutableReference();
 			ref.setSimpleName(CtExecutableReference.CONSTRUCTOR_NAME);
 			ref.setDeclaringType(getTypeReference(null, allocationExpression.type));
 
-			final List<CtTypeReference<?>> parameters = new ArrayList<>(allocationExpression.argumentTypes.length);
+			final List<CtTypeReference<?>> parameters =
+					new ArrayList<>(allocationExpression.argumentTypes.length);
 			for (TypeBinding b : allocationExpression.argumentTypes) {
 				parameters.add(getTypeReference(b, true));
 			}
@@ -466,6 +472,35 @@ <T> CtExecutableReference<T> getExecutableReference(AllocationExpression allocat
 		return ref;
 	}
 
+	/**
+	 * Checks if the given executable reference is incorrectly bound to the Object type and noclasspath is set.
+	 * @param ref  the executable reference to check
+	 * @param allocationExpression  the allocation expression that contains the executable reference of jdt.
+	 * @return  true if the executable reference is incorrectly bound to the Object type and noclasspath is set.
+	 */
+	@NoClasspathWorkaround(reason =  "https://github.com/INRIA/spoon/issues/4643")
+	private boolean isIncorrectlyBoundExecutableInNoClasspath(CtExecutableReference<?> ref,
+			AllocationExpression allocationExpression) {
+		boolean noClasspath = ref.getFactory().getEnvironment().getNoClasspath();
+		return noClasspath && ref.getType().equals(ref.getFactory().Type().objectType())
+				&& allocationExpression.resolvedType != null;
+	}
+
+	/**
+	 * Adjusts the executable reference according to the resolved type. This is needed because the binding is not correct in no classpath.
+	 * @param ref the executable reference to adjust
+	 * @param allocationExpression  the allocation expression that contains the executable reference of jdt.
+	 */
+	@NoClasspathWorkaround(reason =  "https://github.com/INRIA/spoon/issues/4643")
+	@SuppressWarnings("unchecked")
+	private void adjustExecutableAccordingToResolvedType(CtExecutableReference ref,
+			AllocationExpression allocationExpression) {
+		CtTypeReference<?> resolvedTypeRef = getTypeReference(allocationExpression.resolvedType);
+		ref.setType(resolvedTypeRef);
+		ref.getExecutableDeclaration().setType(resolvedTypeRef);
+		ref.setDeclaringType(resolvedTypeRef);
+	}
+
 	<T> CtExecutableReference<T> getExecutableReference(MessageSend messageSend) {
 		if (messageSend.binding != null) {
 			return getExecutableReference(messageSend.binding);

src/test/java/spoon/test/constructorcallnewclass/ConstructorCallTest.java

@@ -22,7 +22,6 @@
 import java.util.List;
 import java.util.TreeSet;
 import java.util.stream.Collectors;
-
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import spoon.Launcher;
@@ -42,6 +41,7 @@
 
 
 import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertSame;
@@ -221,4 +221,18 @@ private CtTypeReference<?> getConstructorCallTypeFrom(String simpleName, String
 		assert calls.size() == 1;
 		return calls.get(0).getExecutable().getType();
 	}
+
+	@Test
+	public void testConstructorCorrectTyped() {
+		// no constructorcall from the input has the simple object type in noclasspathmode
+		Launcher launcher = new Launcher();
+		launcher.getEnvironment().setNoClasspath(true);
+		launcher.addInputResource("./src/test/resources/constructorcall-type/ConstructorCallWithTypesNotOnClasspath.java");
+		CtModel model = launcher.buildModel();
+		for (CtConstructorCall<?> ctConstructorCall : model
+				.getElements(new TypeFilter<>(CtConstructorCall.class))) {
+			assertThat(ctConstructorCall.getExecutable().getType().getSimpleName(), not(equalTo("Object")));
+			assertThat(ctConstructorCall.getType(), not(ctConstructorCall.getFactory().Type().objectType()));
+		}
+	}
 }

src/test/resources/constructorcall-type/ConstructorCallWithTypesNotOnClasspath.java

@@ -0,0 +1,7 @@
+class ConstructorCallWithTypesNotOnClasspath {
+    public static void main(String[] args) {
+        type.not.on.Classpath instanceOfTypeNotOnClasspath = null;
+        new another.type.not.on.Classpath(instanceOfTypeNotOnClasspath);
+    }
+}
+