コード例 #1
0
 protected String getRawTypeIdentifier(JvmTypeReference reference) {
   if (reference instanceof JvmParameterizedTypeReference) {
     JvmType typeOrProxy =
         (JvmType)
             reference.eGet(TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE, false);
     if (typeOrProxy.eIsProxy()) {
       URI uri = ((InternalEObject) typeOrProxy).eProxyURI();
       if (URIHelperConstants.PROTOCOL.equals(uri.scheme())) {
         if (URIHelperConstants.PRIMITIVES.regionMatches(
             1, uri.segment(0), 0, URIHelperConstants.PRIMITIVES.length() - 1)) {
           String fragment = uri.fragment();
           return fragment;
         } else if (URIHelperConstants.OBJECTS.regionMatches(
             1, uri.segment(0), 0, URIHelperConstants.OBJECTS.length() - 2)) {
           String fragment = uri.fragment();
           if (fragment.lastIndexOf('/') == -1) return fragment;
         }
       }
     }
   }
   RawTypeReferenceComputer strategy = new RawTypeReferenceComputer(TypesFactory.eINSTANCE);
   JvmTypeReference result = strategy.getRawTypeReference(reference, eResource());
   if (result == null) return null;
   JvmType rawResult = result.getType();
   return rawResult == null ? null : rawResult.getIdentifier();
 }
コード例 #2
0
ファイル: JvmModelTests.java プロジェクト: NiciaB/xtext
 @Test
 public void testEmptyListAsAnnotationValueDefault() {
   try {
     StringConcatenation _builder = new StringConcatenation();
     _builder.append("annotation Foo {");
     _builder.newLine();
     _builder.append("\t");
     _builder.append("String[] bar = #[]");
     _builder.newLine();
     _builder.append("}");
     _builder.newLine();
     String _string = _builder.toString();
     XtendAnnotationType _annotationType = this.annotationType(_string);
     JvmAnnotationType _inferredAnnotationType =
         this._iXtendJvmAssociations.getInferredAnnotationType(_annotationType);
     EList<JvmMember> _members = _inferredAnnotationType.getMembers();
     JvmMember _head = IterableExtensions.<JvmMember>head(_members);
     final JvmOperation inferred = ((JvmOperation) _head);
     JvmTypeReference _returnType = inferred.getReturnType();
     String _identifier = _returnType.getIdentifier();
     Assert.assertEquals("java.lang.String[]", _identifier);
     JvmAnnotationValue _defaultValue = inferred.getDefaultValue();
     Assert.assertTrue((_defaultValue instanceof JvmStringAnnotationValue));
     JvmAnnotationValue _defaultValue_1 = inferred.getDefaultValue();
     EList<String> _values = ((JvmStringAnnotationValue) _defaultValue_1).getValues();
     boolean _isEmpty = _values.isEmpty();
     Assert.assertTrue(_isEmpty);
   } catch (Throwable _e) {
     throw Exceptions.sneakyThrow(_e);
   }
 }
 protected boolean areArgumentTypesValid(JvmExecutable exectuable, List<XExpression> arguments) {
   int numberOfParameters = exectuable.getParameters().size();
   int parametersToCheck = exectuable.isVarArgs() ? numberOfParameters - 1 : numberOfParameters;
   for (int i = 0; i < parametersToCheck; i++) {
     JvmTypeReference parameterType = exectuable.getParameters().get(i).getParameterType();
     XExpression argument = arguments.get(i);
     JvmTypeReference argumentType = getTypeProvider().getType(argument, true);
     if (parameterType == null) return true;
     if (!isCompatibleArgument(parameterType, argumentType)) return false;
   }
   if (exectuable.isVarArgs()) {
     int lastParamIndex = numberOfParameters - 1;
     JvmTypeReference lastParameterType =
         exectuable.getParameters().get(lastParamIndex).getParameterType();
     if (!(lastParameterType.getType() instanceof JvmArrayType))
       throw new IllegalStateException("Unexpected var arg type: " + lastParameterType);
     JvmTypeReference varArgType = ((JvmArrayType) lastParameterType.getType()).getComponentType();
     if (arguments.size() == numberOfParameters) {
       XExpression lastArgument = arguments.get(lastParamIndex);
       JvmTypeReference lastArgumentType = getTypeProvider().getType(lastArgument, true);
       if (isCompatibleArgument(lastParameterType, lastArgumentType)) return true;
       if (!isCompatibleArgument(varArgType, lastArgumentType)) return false;
     } else {
       for (int i = lastParamIndex; i < arguments.size(); i++) {
         XExpression argumentExpression = arguments.get(i);
         JvmTypeReference argumentType = getTypeProvider().getType(argumentExpression, true);
         if (!isCompatibleArgument(varArgType, argumentType)) return false;
       }
     }
   }
   return true;
 }
コード例 #4
0
 protected SignatureHashBuilder appendType(JvmTypeReference ref) {
   if (ref != null && ref.getIdentifier() != null) {
     append(ref.getIdentifier());
   } else {
     append("*unresolved*");
   }
   return this;
 }
コード例 #5
0
 @Override
 public JvmTypeReference getExtendedClass() {
   for (JvmTypeReference candidate : getSuperTypes()) {
     if (candidate.getType() instanceof JvmGenericType
         && !((JvmGenericType) candidate.getType()).isInterface()) return candidate;
   }
   return null;
 }
 protected boolean isCompatibleArgument(
     JvmTypeReference declaredType, JvmTypeReference actualType) {
   if (actualType == null) return true;
   if (actualType.getType() instanceof JvmTypeParameter) {
     JvmTypeParameter type = (JvmTypeParameter) actualType.getType();
     if (type.getConstraints().isEmpty()) return true;
     for (JvmTypeConstraint constraint : type.getConstraints()) {
       if (isCompatibleArgument(declaredType, constraint.getTypeReference())) return true;
     }
     return false;
   }
   return conformance.isConformant(declaredType, actualType, true);
 }
 public Iterable<? extends JvmFeature> getFeaturesForType(JvmTypeReference declType) {
   if (declType instanceof JvmAnyTypeReference || declType instanceof JvmMultiTypeReference) {
     return Collections.emptyList();
   }
   if (declType != null && declType.getType() instanceof JvmDeclaredType) {
     return filter(
         filter(((JvmDeclaredType) declType.getType()).getMembers(), JvmFeature.class),
         new Predicate<JvmFeature>() {
           public boolean apply(JvmFeature input) {
             return !(input instanceof JvmConstructor);
           }
         });
   }
   return emptySet();
 }
コード例 #8
0
 protected void createInheritedFeatureNodes(
     IOutlineNode parentNode,
     JvmDeclaredType baseType,
     Set<JvmFeature> processedFeatures,
     int inheritanceDepth,
     JvmTypeReference superType) {
   if (superType.getType() instanceof JvmDeclaredType) {
     JvmDeclaredType superClass = ((JvmGenericType) superType.getType());
     EObject xtendSuperClass = associations.getPrimarySourceElement(superType.getType());
     createFeatureNodesForType(
         parentNode,
         (XtendTypeDeclaration) xtendSuperClass,
         superClass,
         baseType,
         processedFeatures,
         inheritanceDepth + 1);
   }
 }
コード例 #9
0
    protected SignatureHashBuilder appendSuperTypeSignatures(JvmDeclaredType type) {
      Set<JvmTypeReference> allSuperTypes = superTypeCollector.collectSuperTypes(type);
      Collection<JvmType> transformedSuperTypes =
          Lists.newArrayList(
              (Iterables.transform(
                  allSuperTypes,
                  new Function<JvmTypeReference, JvmType>() {
                    public JvmType apply(JvmTypeReference input) {
                      return input.getType();
                    }
                  })));
      // The inheritance hierarchy contains cycles -> stop calculation here
      if (transformedSuperTypes.contains(type)) return this;
      for (JvmTypeReference superType : allSuperTypes) {
        append("super ");
        superType.accept(
            new org.eclipse.xtext.common.types.util.AbstractTypeReferenceVisitor.InheritanceAware<
                Void>() {
              @Override
              public Void doVisitTypeReference(JvmTypeReference reference) {
                if (reference.getType() instanceof JvmDeclaredType)
                  append(hashProvider.getHash((JvmDeclaredType) reference.getType()));
                else append(reference.getIdentifier());
                return null;
              }

              @Override
              public Void doVisitParameterizedTypeReference(
                  JvmParameterizedTypeReference reference) {
                doVisitTypeReference(reference);
                append("<");
                for (JvmTypeReference typeArgument : reference.getArguments()) {
                  append(typeArgument.getIdentifier());
                  append(",");
                }
                append(">");
                return null;
              }
            });
        append("\n");
      }
      return this;
    }
コード例 #10
0
ファイル: TypeReferences.java プロジェクト: ramons03/xtext
 public JvmTypeReference getArgument(JvmTypeReference left, int index) {
   if (left.getType() instanceof JvmGenericType) {
     List<JvmTypeParameter> typeParameters = ((JvmGenericType) left.getType()).getTypeParameters();
     if (typeParameters.size() <= index) {
       throw new IllegalArgumentException(
           "The type "
               + left.getType().getIdentifier()
               + " cannot be parameterized with more than "
               + typeParameters.size()
               + " type arguments.");
     }
     if (left instanceof JvmParameterizedTypeReference) {
       List<JvmTypeReference> arguments = ((JvmParameterizedTypeReference) left).getArguments();
       if (arguments.size() == typeParameters.size()) {
         return arguments.get(index);
       }
     }
     final JvmTypeParameter jvmTypeParameter = typeParameters.get(index);
     return createTypeRef(jvmTypeParameter);
   }
   throw new IllegalArgumentException(left.getType().getIdentifier() + " is not generic.");
 }
コード例 #11
0
ファイル: JvmModelTests.java プロジェクト: NiciaB/xtext
 @Test
 public void testInterfaceImplicitSuperType() {
   try {
     StringConcatenation _builder = new StringConcatenation();
     _builder.append("interface Foo {");
     _builder.newLine();
     _builder.append("}");
     _builder.newLine();
     String _string = _builder.toString();
     XtendInterface _interfaze = this.interfaze(_string);
     final JvmGenericType inferred = this._iXtendJvmAssociations.getInferredType(_interfaze);
     EList<JvmTypeReference> _superTypes = inferred.getSuperTypes();
     int _size = _superTypes.size();
     Assert.assertEquals(1, _size);
     EList<JvmTypeReference> _superTypes_1 = inferred.getSuperTypes();
     JvmTypeReference _head = IterableExtensions.<JvmTypeReference>head(_superTypes_1);
     String _identifier = _head.getIdentifier();
     Assert.assertEquals("java.lang.Object", _identifier);
   } catch (Throwable _e) {
     throw Exceptions.sneakyThrow(_e);
   }
 }
コード例 #12
0
ファイル: TypeReferences.java プロジェクト: ramons03/xtext
 public boolean isNullOrProxy(final JvmTypeReference reference) {
   return reference == null || reference.getType() == null || reference.getType().eIsProxy();
 }
コード例 #13
0
ファイル: TypeReferences.java プロジェクト: ramons03/xtext
 public boolean is(final JvmTypeReference reference, final Class<?> clazz) {
   if (isNullOrProxy(reference)) return false;
   final boolean equals = clazz.getCanonicalName().equals(reference.getType().getIdentifier());
   return equals;
 }
コード例 #14
0
 protected void addNameAndDescription(
     final ContentAssistEntry entry,
     final JvmFeature feature,
     final boolean withParents,
     final int insignificantParameters,
     final String shortName,
     final LightweightTypeReferenceFactory converter) {
   final StringBuilder labelBuilder = new StringBuilder(shortName);
   final StringBuilder descriptionBuilder = new StringBuilder();
   if ((feature instanceof JvmOperation)) {
     if (withParents) {
       labelBuilder.append("(");
       this.appendParameters(
           labelBuilder, ((JvmExecutable) feature), insignificantParameters, converter);
       labelBuilder.append(")");
     }
     final JvmTypeReference returnType = ((JvmOperation) feature).getReturnType();
     boolean _and = false;
     boolean _notEquals = (!Objects.equal(returnType, null));
     if (!_notEquals) {
       _and = false;
     } else {
       String _simpleName = returnType.getSimpleName();
       boolean _notEquals_1 = (!Objects.equal(_simpleName, null));
       _and = _notEquals_1;
     }
     if (_and) {
       labelBuilder.append(" : ");
       LightweightTypeReference _lightweightReference =
           converter.toLightweightReference(returnType);
       String _humanReadableName = _lightweightReference.getHumanReadableName();
       labelBuilder.append(_humanReadableName);
     }
     JvmDeclaredType _declaringType = ((JvmOperation) feature).getDeclaringType();
     LightweightTypeReference _plainTypeReference = converter.toPlainTypeReference(_declaringType);
     String _humanReadableName_1 = _plainTypeReference.getHumanReadableName();
     descriptionBuilder.append(_humanReadableName_1);
     if ((!withParents)) {
       descriptionBuilder.append(".");
       String _simpleName_1 = ((JvmOperation) feature).getSimpleName();
       descriptionBuilder.append(_simpleName_1);
       descriptionBuilder.append("()");
     }
   } else {
     if ((feature instanceof JvmField)) {
       labelBuilder.append(" : ");
       JvmTypeReference _type = ((JvmField) feature).getType();
       boolean _notEquals_2 = (!Objects.equal(_type, null));
       if (_notEquals_2) {
         JvmTypeReference _type_1 = ((JvmField) feature).getType();
         LightweightTypeReference _lightweightReference_1 =
             converter.toLightweightReference(_type_1);
         final String fieldType = _lightweightReference_1.getHumanReadableName();
         boolean _notEquals_3 = (!Objects.equal(fieldType, null));
         if (_notEquals_3) {
           labelBuilder.append(fieldType);
         }
       }
       JvmDeclaredType _declaringType_1 = ((JvmField) feature).getDeclaringType();
       LightweightTypeReference _plainTypeReference_1 =
           converter.toPlainTypeReference(_declaringType_1);
       String _humanReadableName_2 = _plainTypeReference_1.getHumanReadableName();
       descriptionBuilder.append(_humanReadableName_2);
     } else {
       if ((feature instanceof JvmConstructor)) {
         if (withParents) {
           labelBuilder.append("(");
           this.appendParameters(
               labelBuilder, ((JvmExecutable) feature), insignificantParameters, converter);
           labelBuilder.append(")");
         }
       }
     }
   }
   String _string = labelBuilder.toString();
   entry.setLabel(_string);
   String _string_1 = descriptionBuilder.toString();
   entry.setDescription(_string_1);
 }
コード例 #15
0
ファイル: XcoreGenerator.java プロジェクト: johnsteele/emf
 public void generateBodyAnnotations(final XPackage pack) {
   final HashSet<ETypedElement> processed = CollectionLiterals.<ETypedElement>newHashSet();
   EList<XClassifier> _classifiers = pack.getClassifiers();
   for (final XClassifier xClassifier : _classifiers) {
     if ((xClassifier instanceof XDataType)) {
       final XDataType xDataType = ((XDataType) xClassifier);
       XDataTypeMapping _mapping = this.mappings.getMapping(xDataType);
       final EDataType eDataType = _mapping.getEDataType();
       final XBlockExpression createBody = xDataType.getCreateBody();
       XDataTypeMapping _mapping_1 = this.mappings.getMapping(xDataType);
       final JvmOperation creator = _mapping_1.getCreator();
       boolean _and = false;
       boolean _notEquals = (!Objects.equal(createBody, null));
       if (!_notEquals) {
         _and = false;
       } else {
         boolean _notEquals_1 = (!Objects.equal(creator, null));
         _and = (_notEquals && _notEquals_1);
       }
       if (_and) {
         final XcoreAppendable appendable = this.createAppendable();
         EList<JvmFormalParameter> _parameters = creator.getParameters();
         JvmFormalParameter _get = _parameters.get(0);
         appendable.declareVariable(_get, "it");
         JvmTypeReference _returnType = creator.getReturnType();
         Set<JvmTypeReference> _emptySet = Collections.<JvmTypeReference>emptySet();
         this.compiler.compile(createBody, appendable, _returnType, _emptySet);
         String _string = appendable.toString();
         String _extractBody = this.extractBody(_string);
         EcoreUtil.setAnnotation(eDataType, GenModelPackage.eNS_URI, "create", _extractBody);
       }
       final XBlockExpression convertBody = xDataType.getConvertBody();
       XDataTypeMapping _mapping_2 = this.mappings.getMapping(xDataType);
       final JvmOperation converter = _mapping_2.getConverter();
       boolean _and_1 = false;
       boolean _notEquals_2 = (!Objects.equal(convertBody, null));
       if (!_notEquals_2) {
         _and_1 = false;
       } else {
         boolean _notEquals_3 = (!Objects.equal(converter, null));
         _and_1 = (_notEquals_2 && _notEquals_3);
       }
       if (_and_1) {
         final XcoreAppendable appendable_1 = this.createAppendable();
         EList<JvmFormalParameter> _parameters_1 = converter.getParameters();
         JvmFormalParameter _get_1 = _parameters_1.get(0);
         appendable_1.declareVariable(_get_1, "it");
         JvmTypeReference _returnType_1 = converter.getReturnType();
         Set<JvmTypeReference> _emptySet_1 = Collections.<JvmTypeReference>emptySet();
         this.compiler.compile(convertBody, appendable_1, _returnType_1, _emptySet_1);
         String _string_1 = appendable_1.toString();
         String _extractBody_1 = this.extractBody(_string_1);
         EcoreUtil.setAnnotation(eDataType, GenModelPackage.eNS_URI, "convert", _extractBody_1);
       }
     } else {
       final XClass xClass = ((XClass) xClassifier);
       XClassMapping _mapping_3 = this.mappings.getMapping(xClass);
       final EClass eClass = _mapping_3.getEClass();
       EList<EStructuralFeature> _eAllStructuralFeatures = eClass.getEAllStructuralFeatures();
       for (final EStructuralFeature eStructuralFeature : _eAllStructuralFeatures) {
         boolean _add = processed.add(eStructuralFeature);
         if (_add) {
           final XStructuralFeature xFeature = this.mappings.getXFeature(eStructuralFeature);
           boolean _notEquals_4 = (!Objects.equal(xFeature, null));
           if (_notEquals_4) {
             final XBlockExpression getBody = xFeature.getGetBody();
             boolean _notEquals_5 = (!Objects.equal(getBody, null));
             if (_notEquals_5) {
               XFeatureMapping _mapping_4 = this.mappings.getMapping(xFeature);
               final JvmOperation getter = _mapping_4.getGetter();
               final XcoreAppendable appendable_2 = this.createAppendable();
               JvmTypeReference _returnType_2 = getter.getReturnType();
               Set<JvmTypeReference> _emptySet_2 = Collections.<JvmTypeReference>emptySet();
               this.compiler.compile(getBody, appendable_2, _returnType_2, _emptySet_2);
               String _string_2 = appendable_2.toString();
               String _extractBody_2 = this.extractBody(_string_2);
               EcoreUtil.setAnnotation(
                   eStructuralFeature, GenModelPackage.eNS_URI, "get", _extractBody_2);
             }
           }
         }
       }
       EList<EOperation> _eAllOperations = eClass.getEAllOperations();
       for (final EOperation eOperation : _eAllOperations) {
         boolean _add_1 = processed.add(eOperation);
         if (_add_1) {
           final XOperation xOperation = this.mappings.getXOperation(eOperation);
           boolean _notEquals_6 = (!Objects.equal(xOperation, null));
           if (_notEquals_6) {
             final XBlockExpression body = xOperation.getBody();
             boolean _notEquals_7 = (!Objects.equal(body, null));
             if (_notEquals_7) {
               XOperationMapping _mapping_5 = this.mappings.getMapping(xOperation);
               final JvmOperation jvmOperation = _mapping_5.getJvmOperation();
               boolean _notEquals_8 = (!Objects.equal(jvmOperation, null));
               if (_notEquals_8) {
                 final XcoreAppendable appendable_3 = this.createAppendable();
                 JvmDeclaredType _declaringType = jvmOperation.getDeclaringType();
                 appendable_3.declareVariable(_declaringType, "this");
                 JvmDeclaredType _declaringType_1 = jvmOperation.getDeclaringType();
                 EList<JvmTypeReference> _superTypes = _declaringType_1.getSuperTypes();
                 final JvmTypeReference superType =
                     IterableExtensions.<JvmTypeReference>head(_superTypes);
                 boolean _notEquals_9 = (!Objects.equal(superType, null));
                 if (_notEquals_9) {
                   JvmType _type = superType.getType();
                   appendable_3.declareVariable(_type, "super");
                 }
                 EList<JvmFormalParameter> _parameters_2 = jvmOperation.getParameters();
                 for (final JvmFormalParameter parameter : _parameters_2) {
                   String _name = parameter.getName();
                   appendable_3.declareVariable(parameter, _name);
                 }
                 JvmTypeReference _returnType_3 = jvmOperation.getReturnType();
                 EList<JvmTypeReference> _exceptions = jvmOperation.getExceptions();
                 HashSet<JvmTypeReference> _hashSet = new HashSet<JvmTypeReference>(_exceptions);
                 this.compiler.compile(body, appendable_3, _returnType_3, _hashSet);
                 String _string_3 = appendable_3.toString();
                 String _extractBody_3 = this.extractBody(_string_3);
                 EcoreUtil.setAnnotation(
                     eOperation, GenModelPackage.eNS_URI, "body", _extractBody_3);
               }
             }
           }
         }
       }
     }
   }
 }
コード例 #16
0
 protected void assertCommonSuperType(String expected, List<JvmTypeReference> refs) {
   JvmTypeReference type = getComputer().getCommonSuperType(refs);
   assertEquals(expected, type.getIdentifier());
 }
コード例 #17
0
  protected void convertFunctionType(
      final JvmTypeReference expectedType,
      final JvmTypeReference functionType,
      final ITreeAppendable appendable,
      final Later expression,
      XExpression context) {
    //		JvmTypeReference resolvedLeft = closures.getResolvedExpectedType(expectedType,
    // functionType);
    if (expectedType.getIdentifier().equals(Object.class.getName())
        || EcoreUtil.equals(expectedType.getType(), functionType.getType())
        || ((expectedType instanceof JvmSynonymTypeReference)
            && Iterables.any(
                ((JvmSynonymTypeReference) expectedType).getReferences(),
                new Predicate<JvmTypeReference>() {
                  public boolean apply(@Nullable JvmTypeReference ref) {
                    return EcoreUtil.equals(ref.getType(), functionType.getType());
                  }
                }))) {
      // same raw type but different type parameters
      // at this point we know that we are compatible so we have to convince the Java compiler about
      // that ;-)
      if (!getTypeConformanceComputer().isConformant(expectedType, functionType)) {
        // insert a cast
        appendable.append("(");
        serialize(expectedType, context, appendable);
        appendable.append(")");
      }
      expression.exec(appendable);
      return;
    }
    JvmOperation operation = closures.findImplementingOperation(expectedType, context.eResource());
    if (operation == null) {
      throw new IllegalStateException(
          "expected type " + expectedType + " not mappable from " + functionType);
    }
    JvmType declaringType =
        (expectedType instanceof JvmParameterizedTypeReference)
            ? expectedType.getType()
            : operation.getDeclaringType();
    final JvmTypeReference typeReferenceWithPlaceHolder =
        getTypeReferences().createTypeRef(declaringType);
    ITypeArgumentContext typeArgumentContext =
        contextProvider.getTypeArgumentContext(
            new TypeArgumentContextProvider.AbstractRequest() {
              @Override
              public JvmTypeReference getExpectedType() {
                return functionType;
              }

              @Override
              public JvmTypeReference getDeclaredType() {
                return typeReferenceWithPlaceHolder;
              }

              @Override
              public String toString() {
                return "TypeConvertingCompiler.convertFunctionType [expected="
                    + functionType
                    + ",declared="
                    + typeReferenceWithPlaceHolder
                    + "]";
              }
            });
    JvmTypeReference resolvedExpectedType =
        typeArgumentContext.resolve(typeReferenceWithPlaceHolder);
    appendable.append("new ");
    serialize(resolvedExpectedType, context, appendable, true, false);
    appendable.append("() {");
    appendable.increaseIndentation().increaseIndentation();
    appendable.newLine().append("public ");
    serialize(
        typeArgumentContext.resolve(operation.getReturnType()), context, appendable, true, false);
    appendable.append(" ").append(operation.getSimpleName()).append("(");
    EList<JvmFormalParameter> params = operation.getParameters();
    for (Iterator<JvmFormalParameter> iterator = params.iterator(); iterator.hasNext(); ) {
      JvmFormalParameter p = iterator.next();
      final String name = p.getName();
      serialize(
          typeArgumentContext.resolve(p.getParameterType()), context, appendable, false, false);
      appendable.append(" ").append(name);
      if (iterator.hasNext()) appendable.append(",");
    }
    appendable.append(") {");
    appendable.increaseIndentation();
    if (!getTypeReferences().is(operation.getReturnType(), Void.TYPE))
      appendable.newLine().append("return ");
    else appendable.newLine();
    expression.exec(appendable);
    appendable.append(".");
    JvmOperation actualOperation =
        closures.findImplementingOperation(functionType, context.eResource());
    appendable.append(actualOperation.getSimpleName());
    appendable.append("(");
    for (Iterator<JvmFormalParameter> iterator = params.iterator(); iterator.hasNext(); ) {
      JvmFormalParameter p = iterator.next();
      final String name = p.getName();
      appendable.append(name);
      if (iterator.hasNext()) appendable.append(",");
    }
    appendable.append(");");
    appendable.decreaseIndentation();
    appendable.newLine().append("}");
    appendable.decreaseIndentation().decreaseIndentation();
    appendable.newLine().append("}");
  }
コード例 #18
0
ファイル: TypeReferences.java プロジェクト: ramons03/xtext
 public boolean isArray(JvmTypeReference type) {
   if (isNullOrProxy(type)) return false;
   return type instanceof JvmGenericArrayTypeReference || type.getType() instanceof JvmArrayType;
 }
コード例 #19
0
 private String getTypeName(JvmTypeReference type) {
   return type.getQualifiedName();
 }
コード例 #20
0
 protected JvmType getRawType(JvmTypeReference reference) {
   RawTypeReferenceComputer strategy = new RawTypeReferenceComputer(TypesFactory.eINSTANCE);
   JvmTypeReference result = strategy.getRawTypeReference(reference, eResource());
   return result == null ? null : result.getType();
 }
コード例 #21
0
 public void serialize(
     final JvmTypeReference type,
     EObject context,
     IAppendable appendable,
     boolean withoutConstraints,
     boolean paramsToWildcard,
     boolean paramsToObject,
     boolean allowPrimitives) {
   IAppendable tracedAppendable = appendable;
   boolean tracing = false;
   if (appendable instanceof ITreeAppendable && type.eResource() == context.eResource()) {
     tracedAppendable = ((ITreeAppendable) appendable).trace(type);
     tracing = true;
   }
   if (type instanceof JvmWildcardTypeReference) {
     JvmWildcardTypeReference wildcard = (JvmWildcardTypeReference) type;
     if (!withoutConstraints) {
       tracedAppendable.append("?");
     }
     if (!wildcard.getConstraints().isEmpty()) {
       for (JvmTypeConstraint constraint : wildcard.getConstraints()) {
         if (constraint instanceof JvmLowerBound) {
           if (!withoutConstraints) tracedAppendable.append(" super ");
           serialize(
               constraint.getTypeReference(),
               context,
               tracedAppendable,
               withoutConstraints,
               paramsToWildcard,
               paramsToObject,
               false);
           return;
         }
       }
       boolean first = true;
       for (JvmTypeConstraint constraint : wildcard.getConstraints()) {
         if (constraint instanceof JvmUpperBound) {
           if (first) {
             if (!withoutConstraints) tracedAppendable.append(" extends ");
             first = false;
           } else {
             if (withoutConstraints)
               throw new IllegalStateException(
                   "cannot have two upperbounds if type should be printed without constraints");
             tracedAppendable.append(" & ");
           }
           serialize(
               constraint.getTypeReference(),
               context,
               tracedAppendable,
               withoutConstraints,
               paramsToWildcard,
               paramsToObject,
               false);
         }
       }
     } else if (withoutConstraints) {
       tracedAppendable.append("Object");
     }
   } else if (type instanceof JvmGenericArrayTypeReference) {
     serialize(
         ((JvmGenericArrayTypeReference) type).getComponentType(),
         context,
         tracedAppendable,
         withoutConstraints,
         paramsToWildcard,
         paramsToObject,
         true);
     tracedAppendable.append("[]");
   } else if (type instanceof JvmParameterizedTypeReference) {
     JvmParameterizedTypeReference parameterized = (JvmParameterizedTypeReference) type;
     if ((paramsToWildcard || paramsToObject)
         && parameterized.getType() instanceof JvmTypeParameter) {
       JvmTypeParameter parameter = (JvmTypeParameter) parameterized.getType();
       if (!isLocalTypeParameter(context, parameter)) {
         if (paramsToWildcard) tracedAppendable.append("?");
         else tracedAppendable.append("Object");
         return;
       }
     }
     JvmType jvmType =
         allowPrimitives ? type.getType() : primitives.asWrapperTypeIfPrimitive(type).getType();
     if (tracing) {
       ITextRegion region =
           locationProvider.getFullTextRegion(
               type, TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE, 0);
       if (region instanceof ITextRegionWithLineInformation) {
         ((ITreeAppendable) tracedAppendable)
             .trace(new LocationData((ITextRegionWithLineInformation) region, null))
             .append(jvmType);
       } else {
         tracedAppendable.append(jvmType);
       }
     } else {
       tracedAppendable.append(jvmType);
     }
     if (!parameterized.getArguments().isEmpty()) {
       tracedAppendable.append("<");
       for (int i = 0; i < parameterized.getArguments().size(); i++) {
         if (i != 0) {
           tracedAppendable.append(",");
         }
         serialize(
             parameterized.getArguments().get(i),
             context,
             tracedAppendable,
             withoutConstraints,
             paramsToWildcard,
             paramsToObject,
             false);
       }
       tracedAppendable.append(">");
     }
   } else if (type instanceof JvmAnyTypeReference) {
     tracedAppendable.append("Object");
   } else if (type instanceof JvmMultiTypeReference) {
     serialize(
         resolveMultiType(type, context),
         context,
         tracedAppendable,
         withoutConstraints,
         paramsToWildcard,
         paramsToObject,
         allowPrimitives);
   } else if (type instanceof JvmDelegateTypeReference) {
     JvmTypeReference delegate = ((JvmDelegateTypeReference) type).getDelegate();
     if (delegate != null)
       serialize(
           delegate,
           context,
           tracedAppendable,
           withoutConstraints,
           paramsToWildcard,
           paramsToObject,
           allowPrimitives);
     else tracedAppendable.append("Object");
   } else if (type instanceof JvmSpecializedTypeReference) {
     serialize(
         ((JvmSpecializedTypeReference) type).getEquivalent(),
         context,
         tracedAppendable,
         withoutConstraints,
         paramsToWildcard,
         paramsToObject,
         allowPrimitives);
   } else if (type instanceof JvmUnknownTypeReference) {
     if (type.eIsSet(TypesPackage.Literals.JVM_UNKNOWN_TYPE_REFERENCE__QUALIFIED_NAME)) {
       tracedAppendable.append(type.getQualifiedName());
     } else {
       tracedAppendable.append("Object");
     }
   } else {
     throw new IllegalArgumentException(String.valueOf(type));
   }
 }
コード例 #22
0
 protected boolean identifierStartWith(JvmTypeReference typeReference, String prefix) {
   String identifier = typeReference.getType().getIdentifier();
   if (identifier != null) return identifier.startsWith(prefix);
   return false;
 }