private boolean isValidFunction(JvmOperation op) { // TODO we need context here - the op has to be visible if (op.isAbstract()) { if (Object.class.getName().equals(op.getDeclaringType().getIdentifier())) return false; final String name = op.getSimpleName(); if (name.equals("toString") && op.getParameters().isEmpty()) return false; if (name.equals("equals") && op.getParameters().size() == 1) return false; if (name.equals("hashCode") && op.getParameters().isEmpty()) return false; return true; } return false; }
@Override public void apply(final JvmOperation it) { EList<JvmAnnotationReference> _annotations = it.getAnnotations(); JvmAnnotationReference _annotationRef = PatternMatcherClassInferrer.this.annBuilder.annotationRef(Override.class); PatternMatcherClassInferrer.this._eMFJvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, _annotationRef); it.setVisibility(JvmVisibility.PROTECTED); EList<JvmFormalParameter> _parameters = it.getParameters(); JvmTypeReference _typeRef = PatternMatcherClassInferrer.this.builder.typeRef(Tuple.class); JvmFormalParameter _parameter = PatternMatcherClassInferrer.this._eMFJvmTypesBuilder.toParameter(pattern, "t", _typeRef); PatternMatcherClassInferrer.this._eMFJvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter); } };
@Override public void apply(final JvmOperation it) { it.setVisibility(JvmVisibility.PUBLIC); EList<JvmTypeReference> _exceptions = it.getExceptions(); PatternGroupClassInferrer.this._eMFJvmTypesBuilder.<JvmTypeReference>operator_add(_exceptions, incQueryException); StringConcatenationClient _client = new StringConcatenationClient() { @Override protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) { _builder.append("return "); _builder.append(classRef, ""); _builder.append(".instance();"); } }; PatternGroupClassInferrer.this._eMFJvmTypesBuilder.setBody(it, _client); } };
/** * Returns true, if the given operation matches this dispatch signature and is therefore a case * for this dispatcher. */ public boolean isDispatchCase(JvmOperation operation) { return arity == operation.getParameters().size() && simpleName.equals(operation.getSimpleName()); }
protected OverrideCheckDetails getPrimaryValidDetail(IResolvedOperation overriding, JvmOperation overridden) { OverrideCheckDetails result = OverrideCheckDetails.IMPLEMENTATION; JvmOperation declaration = overriding.getDeclaration(); if (declaration.isStatic()) { result = OverrideCheckDetails.SHADOWED; } else if (declaration.isAbstract()) { if (overridden.isAbstract()) { result = OverrideCheckDetails.REPEATED; } else { result = OverrideCheckDetails.REDECLARATION; } } else if (!overridden.isAbstract()) { result = OverrideCheckDetails.OVERRIDE; } return result; }
@Override public String getValueName() { JvmOperation operation = getOperation(); if (operation == null || operation.eIsProxy()) return null; return operation.getSimpleName(); }
protected void transform(XtendFunction source, JvmGenericType container, boolean allowDispatch) { JvmOperation operation = typesFactory.createJvmOperation(); operation.setAbstract(source.isAbstract()); operation.setNative(source.isNative()); operation.setSynchronized(source.isSynchonized()); operation.setStrictFloatingPoint(source.isStrictFloatingPoint()); if (!source.isAbstract()) operation.setFinal(source.isFinal()); container.getMembers().add(operation); associator.associatePrimary(source, operation); sourceName = "_" + sourceName; operation.setSimpleName(sourceName); operation.setVisibility(visibility); operation.setStatic(source.isStatic()); if (!operation.isAbstract() && !operation.isStatic() && container.isInterface()) operation.setDefault(true); for (XtendParameter parameter : source.getParameters()) { translateParameter(operation, parameter); operation.setReturnType(returnType); copyAndFixTypeParameters(source.getTypeParameters(), operation); for (JvmTypeReference exception : source.getExceptions()) { operation.getExceptions().add(jvmTypesBuilder.cloneWithProxies(exception));
protected SignatureHashBuilder appendSignature(JvmOperation operation) { appendVisibility(operation.getVisibility()).append(" "); if (operation.isAbstract()) append("abstract "); if (operation.isStatic()) append("static "); if (operation.isFinal()) append("final "); appendType(operation.getReturnType()).appendTypeParameters(operation).append(" ") .append(operation.getSimpleName()).append("("); for (JvmFormalParameter p : operation.getParameters()) { appendType(p.getParameterType()); append(" "); } append(") "); for (JvmTypeReference ex : operation.getExceptions()) { appendType(ex).append(" "); } return this; }
/** * Return the local cases that contribute to the given dispatch operation (in no particular order, but usually as defined in the file). */ public List<JvmOperation> getLocalDispatchCases(JvmOperation dispatcherOperation) { DispatchSignature dispatchSignature = new DispatchSignature(dispatcherOperation.getSimpleName(), dispatcherOperation.getParameters().size()); JvmDeclaredType type = dispatcherOperation.getDeclaringType(); return getLocalDispatchCases(type, dispatchSignature); }
private InferredPrototype getInferredPrototype(JvmOperation operation) { final XtendFunction fct = this.associations.getXtendFunction(operation); if (fct != null) { return getInferredPrototype(fct); } final QualifiedActionName actionKey = this.actionPrototypes.createQualifiedActionName( operation.getDeclaringType(), operation.getSimpleName()); // Compute the different action prototypes associated to the action to create. return this.actionPrototypes.createPrototypeFromJvmModel( actionKey, operation.isVarArgs(), operation.getParameters()); }
EObject primarySourceElement = associations.getPrimarySourceElement(element); JvmOperation values = typesFactory.createJvmOperation(); values.setVisibility(JvmVisibility.PUBLIC); values.setStatic(true); values.setSimpleName("values"); values.setReturnType(references.createArrayType(references.createTypeRef(element))); typeExtensions.setSynthetic(values, true); if (primarySourceElement != null) { valueOf.setVisibility(JvmVisibility.PUBLIC); valueOf.setStatic(true); valueOf.setSimpleName("valueOf"); valueOf.setReturnType(references.createTypeRef(element)); JvmFormalParameter param = typesFactory.createJvmFormalParameter(); param.setName("name"); param.setParameterType(references.getTypeForName(String.class, element)); valueOf.getParameters().add(param); typeExtensions.setSynthetic(valueOf, true); if (primarySourceElement != null) {
@Override public void apply(final JvmOperation it) { it.setVisibility(JvmVisibility.PROTECTED); EList<JvmAnnotationReference> _annotations = it.getAnnotations(); JvmAnnotationReference _annotationRef = PatternQuerySpecificationClassInferrer.this.annBuilder.annotationRef(Override.class); PatternQuerySpecificationClassInferrer.this._eMFJvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, _annotationRef); EList<JvmFormalParameter> _parameters = it.getParameters(); JvmTypeReference _typeRef = PatternQuerySpecificationClassInferrer.this.builder.typeRef(IncQueryEngine.class); JvmFormalParameter _parameter = PatternQuerySpecificationClassInferrer.this._eMFJvmTypesBuilder.toParameter(pattern, "engine", _typeRef); PatternQuerySpecificationClassInferrer.this._eMFJvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter); EList<JvmTypeReference> _exceptions = it.getExceptions(); JvmTypeReference _typeRef_1 = PatternQuerySpecificationClassInferrer.this.builder.typeRef(IncQueryException.class); PatternQuerySpecificationClassInferrer.this._eMFJvmTypesBuilder.<JvmTypeReference>operator_add(_exceptions, _typeRef_1);
@Override public void apply(final JvmOperation it) { it.setStatic(true); it.setVisibility(JvmVisibility.PUBLIC); CharSequence _javadocMatcherStaticOnEngine = PatternMatcherClassInferrer.this._javadocInferrer.javadocMatcherStaticOnEngine(pattern); String _string = _javadocMatcherStaticOnEngine.toString(); PatternMatcherClassInferrer.this._eMFJvmTypesBuilder.setDocumentation(it, _string); EList<JvmFormalParameter> _parameters = it.getParameters(); JvmTypeReference _typeRef = PatternMatcherClassInferrer.this.builder.typeRef(IncQueryEngine.class); JvmFormalParameter _parameter = PatternMatcherClassInferrer.this._eMFJvmTypesBuilder.toParameter(pattern, "engine", _typeRef); PatternMatcherClassInferrer.this._eMFJvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter); EList<JvmTypeReference> _exceptions = it.getExceptions(); JvmTypeReference _typeRef_1 = PatternMatcherClassInferrer.this.builder.typeRef(IncQueryException.class); PatternMatcherClassInferrer.this._eMFJvmTypesBuilder.<JvmTypeReference>operator_add(_exceptions, _typeRef_1);
@Override public void apply(final JvmOperation it) { CharSequence _javadocGroupClassInstanceMethod = PatternGroupClassInferrer.this._javadocInferrer.javadocGroupClassInstanceMethod(model); String _string = _javadocGroupClassInstanceMethod.toString(); PatternGroupClassInferrer.this._eMFJvmTypesBuilder.setDocumentation(it, _string); it.setVisibility(JvmVisibility.PUBLIC); it.setStatic(true); EList<JvmTypeReference> _exceptions = it.getExceptions(); PatternGroupClassInferrer.this._eMFJvmTypesBuilder.<JvmTypeReference>operator_add(_exceptions, incQueryException); StringConcatenationClient _client = new StringConcatenationClient() { @Override protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) { _builder.append("if (INSTANCE == null) {"); _builder.newLine(); _builder.append("\t"); _builder.append("INSTANCE = new "); _builder.append(groupClass, "\t"); _builder.append("();"); _builder.newLineIfNotEmpty(); _builder.append("}"); _builder.newLine(); _builder.append("return INSTANCE;"); _builder.newLine(); } }; PatternGroupClassInferrer.this._eMFJvmTypesBuilder.setBody(it, _client); } };
@SuppressWarnings("unused") protected void _computeTypes(Map<JvmIdentifiableElement, ResolvedTypes> preparedResolvedTypes, ResolvedTypes resolvedTypes, IFeatureScopeSession featureScopeSession, JvmOperation operation) { ResolvedTypes childResolvedTypes = preparedResolvedTypes.get(operation); if (childResolvedTypes == null) { if (preparedResolvedTypes.containsKey(operation)) return; throw new IllegalStateException("No resolved type found. Operation was: " + operation.getIdentifier()); } else { preparedResolvedTypes.put(operation, null); } OperationBodyComputationState state = new OperationBodyComputationState(childResolvedTypes, operation.isStatic() ? featureScopeSession : featureScopeSession.toInstanceContext(), operation); addExtensionProviders(state, operation.getParameters()); markComputing(operation.getReturnType()); try { state.computeTypes(); } finally { unmarkComputing(operation.getReturnType()); } computeAnnotationTypes(childResolvedTypes, featureScopeSession, operation); computeLocalTypes(preparedResolvedTypes, childResolvedTypes, featureScopeSession, operation); mergeChildTypes(childResolvedTypes); }
protected static String getPropertyName(final JvmOperation operation, final String methodName, final String prefix, final int params) { String _xblockexpression = null; { final int prefixLength = prefix.length(); String _xifexpression = null; if ((PropertyUtil.startsWithPrefix(methodName, prefix, prefixLength) && (operation.getParameters().size() == params))) { _xifexpression = Introspector.decapitalize(methodName.substring(prefixLength)); } _xblockexpression = _xifexpression; } return _xblockexpression; }
@Override public void apply(final JvmOperation it) { it.setVisibility(JvmVisibility.PUBLIC); EList<JvmTypeReference> _exceptions = it.getExceptions(); PatternGroupClassInferrer.this._eMFJvmTypesBuilder.<JvmTypeReference>operator_add(_exceptions, incQueryException); EList<JvmFormalParameter> _parameters = it.getParameters(); JvmTypeReference _typeRef = PatternGroupClassInferrer.this.builder.typeRef(IncQueryEngine.class); JvmFormalParameter _parameter = PatternGroupClassInferrer.this._eMFJvmTypesBuilder.toParameter(model, "engine", _typeRef); PatternGroupClassInferrer.this._eMFJvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter); StringConcatenationClient _client = new StringConcatenationClient() { @Override protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) { _builder.append("return "); _builder.append(classRef, ""); _builder.append(".on(engine);"); } }; PatternGroupClassInferrer.this._eMFJvmTypesBuilder.setBody(it, _client); } };
@Override protected void checkAssignment(XExpression expression, EStructuralFeature feature, boolean simpleAssignment) { if (simpleAssignment && expression instanceof XAbstractFeatureCall) { final JvmIdentifiableElement assignmentFeature = ((XAbstractFeatureCall) expression).getFeature(); if (assignmentFeature instanceof JvmField) { final JvmField field = (JvmField) assignmentFeature; if (!field.isFinal()) { return; } final JvmIdentifiableElement container = getLogicalContainerProvider().getNearestLogicalContainer(expression); if (container != null && container instanceof JvmOperation) { final JvmOperation operation = (JvmOperation) container; if (operation.isStatic() && field.getDeclaringType() == operation.getDeclaringType() && Utils.STATIC_CONSTRUCTOR_NAME.equals(operation.getSimpleName())) { return; } } } } super.checkAssignment(expression, feature, simpleAssignment); }
@Override public void apply(final JvmOperation it) { JvmTypeReference _typeRef = PatternMatchProcessorClassInferrer.this.builder.typeRef(Void.TYPE); it.setReturnType(_typeRef); EList<JvmAnnotationReference> _annotations = it.getAnnotations(); JvmAnnotationReference _annotationRef = PatternMatchProcessorClassInferrer.this.annBuilder.annotationRef(Override.class); PatternMatchProcessorClassInferrer.this._eMFJvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, _annotationRef); EList<JvmFormalParameter> _parameters = it.getParameters(); JvmTypeReference _typeRef_1 = PatternMatchProcessorClassInferrer.this.builder.typeRef(matchClassRef); JvmFormalParameter _parameter = PatternMatchProcessorClassInferrer.this._eMFJvmTypesBuilder.toParameter(pattern, "match", _typeRef_1);
public void generateAnnotationMethod(final JvmOperation it, final ITreeAppendable appendable, final GeneratorConfig config) { appendable.increaseIndentation().newLine(); appendable.openScope(); this.generateJavaDoc(it, appendable, config); final ITreeAppendable tracedAppendable = appendable.trace(it); this.generateAnnotations(it.getAnnotations(), tracedAppendable, true, config); this.generateModifier(it, tracedAppendable, config); this._errorSafeExtensions.serializeSafely(it.getReturnType(), "Object", tracedAppendable); tracedAppendable.append(" "); this._treeAppendableUtil.traceSignificant(tracedAppendable, it).append(this.makeJavaIdentifier(it.getSimpleName())); tracedAppendable.append("()"); this.generateDefaultExpression(it, tracedAppendable, config); tracedAppendable.append(";"); appendable.decreaseIndentation(); appendable.closeScope(); }