/** * @return return the filename of the current element * @param pack * @param type */ protected String getFileName(CtPackage pack, CtType type) { String fileName; if (type != null) { fileName = type.getSimpleName() + DefaultJavaPrettyPrinter.JAVA_FILE_EXTENSION; } else if (pack != null) { fileName = DefaultJavaPrettyPrinter.JAVA_PACKAGE_DECLARATION; } else { fileName = DefaultJavaPrettyPrinter.JAVA_MODULE_DECLARATION; } return fileName; }
@Override @SuppressWarnings("unchecked") public <T extends CtType<?>> T getType(String simpleName) { for (CtType<?> t : types) { if (t.getSimpleName().equals(simpleName)) { return (T) t; } } return null; }
/** returns true if the given name is a nested type name */ public boolean hasNestedTypeConflict(String name) { if (cachedNestedTypeNames == null) { Collection<CtType<?>> allTypes = type.getNestedTypes(); cachedNestedTypeNames = new HashSet<>(allTypes.size()); for (CtType<?> t : allTypes) { cachedNestedTypeNames.add(t.getSimpleName()); } } return cachedNestedTypeNames.contains(name); }
/** * @param type a spoon model class or interface, whose concept name has to be returned * @return name of {@link MetamodelConcept}, which represents Spoon model {@link CtType} */ public static String getConceptName(CtType<?> type) { return getConceptName(type.getSimpleName()); }
void addRelatedMethod(CtMethod<?> method) { if (method.getDeclaringType().getSimpleName().endsWith("Impl")) { throw new SpoonException("the metametamodel should be entirely specified in the Spoon interfaces"); } ownMethods.add(method); }
@Override public CtType<?> getMainType() { if (getFile() == null) { return getDeclaredTypes().get(0); } for (CtType<?> t : getDeclaredTypes()) { String name = getFile().getName(); name = name.substring(0, name.lastIndexOf('.')); if (t.getSimpleName().equals(name)) { return t; } } throw new RuntimeException( "inconsistent compilation unit: '" + file + "': declared types are " + getDeclaredTypes()); }
public String getGeneratedByComment(CtElement ele) { SourcePosition pos = ele.getPosition(); if (pos != null && pos.isValidPosition()) { CompilationUnit cu = pos.getCompilationUnit(); if (cu != null) { CtType<?> mainType = cu.getMainType(); if (mainType != null) { StringBuilder result = new StringBuilder(); result.append("Generated by "); result.append(mainType.getQualifiedName()); appendInnerTypedElements(result, mainType, ele); result.append('('); result.append(mainType.getSimpleName()); result.append(".java:"); result.append(pos.getLine()); result.append(')'); return result.toString(); } } } return null; } private void appendInnerTypedElements(StringBuilder result, CtType<?> mainType, CtElement ele) {
for (final CtType type : getDeclaredTypes()) { final String nameOfType = type.getSimpleName(); final File fileOfType = new File( base, nameOfType + ".class"); nameOfType + "$" + inner.getSimpleName(); final File fileOfInnerType = new File( base, nameOfInner + ".class");
File file = new File(packageDir.getAbsolutePath() + File.separatorChar + element.getSimpleName() + DefaultJavaPrettyPrinter.JAVA_FILE_EXTENSION); file.createNewFile();
CompilationUnitWrapper(CtType type) { // char[] contents, String fileName, String encoding, String destinationPath, boolean ignoreOptionalProblems super(null, type.getSimpleName() + ".java", type.getFactory().getEnvironment().getEncoding().displayName(), type.getFactory().getEnvironment().getBinaryOutputDirectory(), false, null); this.type = type; }
if (pack != null) { for (CtType<?> packageType : pack.getTypes()) { if (packageType != getScopeElement() && !typesByName.containsKey(packageType.getSimpleName())) { typesByName.put(packageType.getSimpleName(), packageType);
@Override public <T> void visitCtTypeReference(CtTypeReference<T> reference) { assertNotNull(reference); if (CtTypeReference.NULL_TYPE_NAME.equals(reference.getSimpleName()) || "?".equals(reference.getSimpleName())) { super.visitCtTypeReference(reference); return; } final CtType<T> typeDeclaration = reference.getTypeDeclaration(); assertNotNull(reference.toString() + " cannot be found in ", typeDeclaration); assertEquals(reference.getSimpleName(), typeDeclaration.getSimpleName()); assertEquals(reference.getQualifiedName(), typeDeclaration.getQualifiedName()); if (reference.getDeclaration() == null) { assertTrue("typeDeclaration must be shadow", typeDeclaration.isShadow()); } super.visitCtTypeReference(reference); }
/** * Generates type in the package `ownerPackage` with simple name `typeSimpleName` using this {@link Generator} and provided `params` * * Note: the root of pattern element must be one or more types. * * @param ownerPackage the target package * @param typeSimpleName the simple name of future generated type * @param params the pattern parameters * @return the generated type */ @SuppressWarnings("unchecked") private <T extends CtType<?>> T createType(CtPackage ownerPackage, String typeSimpleName, Map<String, Object> params) { @SuppressWarnings({ "rawtypes" }) List<CtType> types = generate(CtType.class, new ImmutableMapImpl(params, PatternBuilder.TARGET_TYPE, ownerPackage.getFactory().Type().createReference(getQualifiedName(ownerPackage, typeSimpleName)))); T result = null; for (CtType<?> type : types) { ownerPackage.addType(type); if (type.getSimpleName().equals(typeSimpleName)) { result = (T) type; } } return result; }
@Override public <T> void visitCtConstructor(CtConstructor<T> constructor) { elementPrinterHelper.writeComment(constructor); elementPrinterHelper.visitCtNamedElement(constructor, sourceCompilationUnit); elementPrinterHelper.writeModifiers(constructor); elementPrinterHelper.writeFormalTypeParameters(constructor); if (!constructor.getFormalCtTypeParameters().isEmpty()) { printer.writeSpace(); } if (constructor.getDeclaringType() != null) { if (constructor.getDeclaringType().isLocalType()) { printer.writeIdentifier(constructor.getDeclaringType().getSimpleName().replaceAll("^[0-9]*", "")); } else { printer.writeIdentifier(constructor.getDeclaringType().getSimpleName()); } } elementPrinterHelper.writeExecutableParameters(constructor); elementPrinterHelper.writeThrowsClause(constructor); printer.writeSpace(); scan(constructor.getBody()); }
StringBuilder tentativeTypeName = new StringBuilder(type.getSimpleName() + "Copy"); while (type.getFactory().Type().get(type.getPackage().getQualifiedName() + "." + tentativeTypeName) != null) { tentativeTypeName.append("X");
@NotNull private static String getAmplifiedName(CtType<?> classTest) { return classTest.getSimpleName().startsWith("Test") ? classTest.getSimpleName() + "Ampl" : "Ampl" + classTest.getSimpleName(); }
@Override @SuppressWarnings("unchecked") public <T extends CtType<?>> T getType(String simpleName) { for (CtType<?> t : types) { if (t.getSimpleName().equals(simpleName)) { return (T) t; } } return null; }
/** * @param includingFormalTypeParameter if true then references to formal type parameters * are added as actual type arguments of returned {@link CtTypeReference} */ public <T> CtTypeReference<T> createReference(CtType<T> type, boolean includingFormalTypeParameter) { CtTypeReference<T> ref = factory.Core().createTypeReference(); if (type.getDeclaringType() != null) { ref.setDeclaringType(createReference(type.getDeclaringType(), includingFormalTypeParameter)); } else if (type.getPackage() != null) { ref.setPackage(factory.Package().createReference(type.getPackage())); } ref.setSimpleName(type.getSimpleName()); if (includingFormalTypeParameter) { for (CtTypeParameter formalTypeParam : type.getFormalCtTypeParameters()) { ref.addActualTypeArgument(formalTypeParam.getReference()); } } return ref; }
@Override public boolean matches(CtLiteral element) { return element.getValue() instanceof String && ((String) element.getValue()).contains(classTest.getSimpleName()); } }).forEach(stringCtLiteral ->
@Override public void process(CtIf element) { String className = element.getPosition().getCompilationUnit().getMainType().getSimpleName(); int line = element.getPosition().getLine(); IfMetric.getExecutedIf().put(IfPosition.create(className, line), new HashMap<String, IfBranch>()); }