@Override public String getIdentifier() { return component.getIdentifier() + "[]"; }
@Override public String apply(/* @Nullable */ LightweightTypeReference reference) { if (reference == null) throw new NullPointerException("reference"); return reference.getIdentifier(); } }
@Override public void accept(LightweightTypeReference type) { if (type != null && seen.add(type.getIdentifier())) { result.add(type); } }
@Override public boolean equals(final Object obj) { if ((obj instanceof TypeReferenceImpl)) { String _identifier = this.getDelegate().getIdentifier(); String _identifier_1 = ((TypeReferenceImpl)obj).getDelegate().getIdentifier(); return Objects.equal(_identifier, _identifier_1); } return false; }
@Override public int hashCode() { return this.getDelegate().getIdentifier().hashCode(); }
public void setType(JvmIdentifiableElement identifiable, LightweightTypeReference reference) { LightweightTypeReference prev = ensureTypesMapExists().put(identifiable, reference); if (prev!= null) { throw new IllegalStateException("identifiable [" + identifiable + "] was already typed as [" + prev.getIdentifier() + "]"); } }
protected void appendParameters(JvmExecutable executable, StringBuilder result, boolean extension) { List<JvmFormalParameter> parameters = executable.getParameters(); int start = extension ? 1 : 0; int end = parameters.size(); if (start != end) { result.append('('); for(int i = start; i < end; i++) { if (i != start) { result.append(','); } JvmFormalParameter parameter = parameters.get(i); LightweightTypeReference parameterType = getParameterType(parameter); if (parameterType != null) result.append(parameterType.getIdentifier()); else result.append("[null]"); } result.append(')'); } }
@Override public String getIdentifier() { if (internalIsResolved()) { return resolvedTo.getIdentifier(); } return "Unbound[" + typeParameter.getIdentifier() + "]"; }
public void assertIdentifiableTypeIsResolved(final JvmIdentifiableElement identifiable, final IResolvedTypes types) { String _simpleName = identifiable.getSimpleName(); boolean _tripleEquals = (_simpleName == null); if (_tripleEquals) { return; } final LightweightTypeReference type = types.getActualType(identifiable); Assert.assertNotNull(identifiable.toString(), type); String _string = identifiable.toString(); String _plus = (_string + " / "); String _plus_1 = (_plus + type); Assert.assertNotNull(_plus_1, type.getIdentifier()); } }
LightweightTypeReference rightRef = components.get(right); if (leftRef.isAssignableFrom(rightRef)) { if (leftRef.getIdentifier().equals(rightRef.getIdentifier())) { if (right > left) { StringBuilder message = new StringBuilder("The caught ");
dataToUse.add(next); } else if (seenReceiverTypes.add(receiverType.getIdentifier())) { dataToUse.add(next);
protected void populateLists(List<QualifiedName> localNames, List<String> localTypes) { Collection<IEObjectDescription> elements = session.getLocalElements(); for(IEObjectDescription desc: elements) { if (TypesPackage.Literals.JVM_IDENTIFIABLE_ELEMENT.isSuperTypeOf(desc.getEClass())) { localNames.add(desc.getName()); JvmIdentifiableElement identifiable = (JvmIdentifiableElement) desc.getEObjectOrProxy(); LightweightTypeReference type = types.getActualType(identifiable); if (type != null) { localTypes.add(type.getRawTypeReference().getIdentifier()); } else { localTypes.add(null); } } } } }
if (!actual.isResolved() || !declaredTypeReference.isResolved() || !Strings.equal(actual.getIdentifier(), declaredTypeReference.getIdentifier())) { if (reference.getType() != actual.getType() || declaredTypeReference.getType() != declaration.getType() || !reference.getIdentifier().equals(actual.getIdentifier()) || !declaredTypeReference.getIdentifier().equals(declaration.getIdentifier())) { outerVisit(declaredTypeReference, actual, declaration, VarianceInfo.INVARIANT, VarianceInfo.INVARIANT);
@Override public IResolvedOperation getAsBottom() { JvmOperation operation = getDeclaration(); JvmDeclaredType declaringType = operation.getDeclaringType(); List<LightweightTypeReference> superTypes = getContextType().getAllSuperTypes(); for(LightweightTypeReference superType: superTypes) { if (superType.getType() == declaringType) { return new BottomResolvedOperation(operation, superType, getBottom().getOverrideTester()); } } throw new IllegalStateException(String.format("Could not find declaring type of method %s in hierarchy of %s", operation.getIdentifier(), getContextType().getIdentifier())); }
} else { final Function1<LightweightTypeReference, Boolean> _function = (LightweightTypeReference it) -> { String _identifier = it.getIdentifier(); return Boolean.valueOf((!Objects.equal("java.lang.Object", _identifier))); };
error(MessageFormat.format(Messages.SARLValidator_45, signature, resolvedReturnType.getIdentifier(), inheritedReturnType.getIdentifier()), sourceElement, sourceReturnTypeFeature, INCOMPATIBLE_RETURN_TYPE, resolvedReturnType.getIdentifier()); sourceElement, returnTypeFeature(sourceElement), RETURN_TYPE_SPECIFICATION_IS_RECOMMENDED, inherited.getResolvedReturnType().getIdentifier());
if (toType.getIdentifier().equals(fromType.getIdentifier())) { addIssue("Unnecessary cast from " + fromType.getHumanReadableName() + " to " + toType.getHumanReadableName(), concreteSyntax, IssueCodes.OBSOLETE_CAST);
_identifier=_actualType.getIdentifier();
if (!expectedType.getIdentifier().equals(actualType.getIdentifier())) { AbstractDiagnostic diagnostic = new EObjectDiagnosticImpl(Severity.ERROR, IssueCodes.INCOMPATIBLE_TYPES, String.format( "Type mismatch: cannot convert from %s to %s", actualType.getHumanReadableName(), expectedType.getHumanReadableName()),
LightweightTypeReference componentType = expectation.getComponentType(); if (componentType == null) { throw new IllegalStateException("Array without component type: " + expectation.getIdentifier());