protected boolean isMatch(int index, JvmType type, String simpleName, QualifiedName relativeName) { return simpleName.equals(type.getSimpleName()); }
@Override public String getSimpleName() { JvmType type = getType(); if (type != null) return type.getSimpleName(); return null; }
@Override public String getSimpleName() { JvmType type = getType(); if (type != null) return type.getSimpleName(); return null; }
@Override public String getSimpleName() { return getAsString(type.getSimpleName(), SimpleNameFunction.INSTANCE); }
private String getFixtureFieldName(final JvmType fixtureType) { return StringExtensions.toFirstLower(fixtureType.getSimpleName()); }
protected void warnRawType(JvmType type, JvmParameterizedTypeReference typeRef) { if (typeRef.eContainer() instanceof XInstanceOfExpression) { return; } StringBuilder message = new StringBuilder(64); message.append(type.getSimpleName()); message.append(" is a raw type. References to generic type "); message = proxyAwareUIStrings.appendTypeSignature(type, message); message.append(" should be parameterized"); warning(message.toString(), IssueCodes.RAW_TYPE, typeRef); }
@Override protected String getAsString(String type, Function<LightweightTypeReference, String> format) { type = format.apply(outer) + "$" + getType().getSimpleName(); return super.getAsString(type, format); }
@Override protected String getAsStringNoFunctionType(String type, Function<LightweightTypeReference, String> format) { type = format.apply(outer) + "$" + getType().getSimpleName(); return super.getAsStringNoFunctionType(type, format); }
@Override protected void doVisitParameterizedTypeReference(ParameterizedTypeReference reference, StringBuilder param) { param.append(reference.getType().getSimpleName()); List<LightweightTypeReference> typeArguments = reference.getTypeArguments(); if (!typeArguments.isEmpty()) { param.append("<"); for(int i = 0; i < typeArguments.size(); i++) { if (i != 0) { param.append(", "); } typeArguments.get(i).accept(this, param); } param.append(">"); } }
private static void appendType(JvmParameterizedTypeReference typeReference, char innerClassDelimiter, NameType nameType, StringBuilder result) { JvmType type = typeReference.getType(); if (type != null) { switch(nameType) { case ID: result.append(type.getIdentifier()); break; case QUALIFIED: result.append(type.getQualifiedName(innerClassDelimiter)); break; case SIMPLE: result.append(type.getSimpleName()); break; case TO_STRING: result.append(type.getIdentifier()); break; } } }
private static String getSignatureType(JvmType type, ImportManager importManager) { if (importManager != null) { importManager.addImportFor(type); return type.getSimpleName(); } return type.getIdentifier(); }
private void checkTypeParameterNotAllowedAsLiteral(EObject ctx, JvmType type, ITypeComputationState state) { if (type instanceof JvmTypeParameter) { state.addDiagnostic(new EObjectDiagnosticImpl( Severity.ERROR, IssueCodes.INVALID_USE_OF_TYPE_PARAMETER, "Illegal class literal for the type parameter " + type.getSimpleName()+".", ctx, null, -1, new String[] { })); } }
@Override protected void doGetDescriptions(JvmType type, JvmType knownType, int index, List<IEObjectDescription> result) { if (type == knownType) { result.add(EObjectDescription.create(QualifiedName.create(type.getSimpleName()), type)); } else if (type.eContainer() == knownType) { result.add(EObjectDescription.create(QualifiedName.create(knownType.getSimpleName(), type.getSimpleName()), type)); result.add(EObjectDescription.create(QualifiedName.create(knownType.getSimpleName() + '$' + type.getSimpleName()), type)); } else { String knownTypeName = knownType.getQualifiedName(); String withDollar = type.getQualifiedName('$'); String withDot = type.getQualifiedName('.'); result.add(EObjectDescription.create(QualifiedName.create(Strings.split(withDot.substring(knownTypeName.length()), '.')), type)); result.add(EObjectDescription.create(QualifiedName.create(withDollar.substring(knownTypeName.length())), type)); } }
public boolean addImportFor(JvmType type) { final String qualifiedName = type.getQualifiedName(getInnerTypeSeparator()); final String simpleName = type.getSimpleName(); final Map<String, String> imps = internalGetImports(); if (!allowsSimpleName(qualifiedName, simpleName) && !needsQualifiedName(qualifiedName, simpleName) && !imps.containsKey(simpleName)) { imps.put(simpleName, qualifiedName); return true; } return false; }
static String computeFor(JvmParameterizedTypeReference typeReference, char innerClassDelimiter, NameType nameType) { if (typeReference.eIsSet(TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE)) { StringBuilder mutableResult = new StringBuilder(64); JvmType type = typeReference.getType(); switch(nameType) { case ID: mutableResult.append(type.getIdentifier()); break; case QUALIFIED: mutableResult.append(type.getQualifiedName(innerClassDelimiter)); break; case SIMPLE: mutableResult.append(type.getSimpleName()); break; case TO_STRING: mutableResult.append(type.getIdentifier()); break; } if (typeReference.eIsSet(TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__ARGUMENTS)) { mutableResult.append("<"); appendArguments(mutableResult, typeReference.getArguments(), innerClassDelimiter, nameType); mutableResult.append(">"); return mutableResult.toString(); } return mutableResult.toString(); } return null; }
public void appendType(final JvmType type, IAcceptor<String> content) { // don't import if a local variable with the same name is on the scope //TODO logic should be moved to ImportManager eventually. if (hasObject(type.getSimpleName())) { content.accept(type.getQualifiedName('.')); } else { StringBuilder builder = new StringBuilder(); importManager.appendType(type, builder); content.accept(builder.toString()); } }
protected void doReassignThisInClosure(final ITreeAppendable b, JvmType prevType) { final String proposedName = prevType.getSimpleName()+".this"; if (!b.hasObject(proposedName)) { b.declareSyntheticVariable(prevType, proposedName); if (b.hasObject("super")) { Object superElement = b.getObject("super"); if (superElement instanceof JvmType) { // Don't reassign the super of the enclosing type if it has already been reassigned String superVariable = b.getName(superElement); if ("super".equals(superVariable)) { b.declareSyntheticVariable(superElement, prevType.getSimpleName()+".super"); } } } } }
protected String getDeclaratorName(JvmFeature feature) { JvmDeclaredType declarator = feature.getDeclaringType(); if (declarator.isLocal()) { return "new " + Iterables.getLast(declarator.getSuperTypes()).getType().getSimpleName()+ "(){}"; } else { return declarator.getSimpleName(); } }
/** Generate a constructor call. * * @param expr the call expression. */ public void generate(XConstructorCall expr) { final List<Object> leftOperand = new ArrayList<>(); final List<Object> receiver = new ArrayList<>(); final JvmConstructor feature = expr.getConstructor(); final List<XExpression> args = getActualArguments(expr); final JvmType type = expr.getConstructor().getDeclaringType(); this.codeReceiver.getImportManager().addImportFor(type); internalAppendCall(feature, leftOperand, receiver, type.getSimpleName(), args, null); }
@Override protected void doVisitInnerTypeReference(final InnerTypeReference reference) { reference.getOuter().accept(this); this.appender.append("."); this.appender.append(reference.getType().getSimpleName()); boolean _isEmpty = reference.getTypeArguments().isEmpty(); boolean _not = (!_isEmpty); if (_not) { this.appender.append("<"); this.appendCommaSeparated(reference.getTypeArguments()); this.appender.append(">"); } }