@Override public Boolean caseXConstructorCall(XConstructorCall object) { JvmConstructor constructor = object.getConstructor(); accept(constructor); return Boolean.TRUE; }
@Override protected List<XExpression> getArguments() { return getConstructorCall().getArguments(); }
@Override protected List<JvmTypeReference> getPlainSyntacticTypeArguments() { return getConstructorCall().getTypeArguments(); }
@Override public void exec(ITreeAppendable appendable) { constructorCallToJavaExpression(expr, appendable); if (expr.eContainer() instanceof AnonymousClass) { JvmConstructor constructor = expr.getConstructor(); JvmDeclaredType declaringType = constructor.getDeclaringType(); compileAnonymousClassBody((AnonymousClass) expr.eContainer(), declaringType, appendable); } } };
@Check public void checkExplicitOperationCall(XConstructorCall constructorCall) { if (!constructorCall.isExplicitConstructorCall() && constructorCall.getArguments().isEmpty()) { addIssue("Constructor call without parentheses", constructorCall, OPERATION_WITHOUT_PARENTHESES); } }
protected Object _doEvaluate(XConstructorCall constructorCall, IEvaluationContext context, CancelIndicator indicator) { JvmConstructor jvmConstructor = constructorCall.getConstructor(); List<Object> arguments = evaluateArgumentExpressions(jvmConstructor, constructorCall.getArguments(), context, indicator); Constructor<?> constructor = javaReflectAccess.getConstructor(jvmConstructor); try { if (constructor == null) throw new NoSuchMethodException("Could not find constructor " + jvmConstructor.getIdentifier()); constructor.setAccessible(true); Object result = constructor.newInstance(arguments.toArray(new Object[arguments.size()])); return result; } catch (InvocationTargetException targetException) { throw new EvaluationException(targetException.getTargetException()); } catch (Exception e) { throw new IllegalStateException("Could not invoke constructor: " + jvmConstructor.getIdentifier(), e); } }
acceptor.accept(constructorCallElements.getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1(), constructorCall.getConstructor()); List<JvmTypeReference> typeArguments = constructorCall.getTypeArguments(); if (!typeArguments.isEmpty()) { acceptor.accept(constructorCallElements.getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0(), typeArguments.get(0), 0); if (constructorCall.isExplicitConstructorCall()) { acceptor.accept(constructorCallElements.getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); List<XExpression> arguments = constructorCall.getArguments(); if (!arguments.isEmpty()) { if (constructorCall.isExplicitConstructorCall() && isXShortClosureAndBuilderSyntax(arguments, XbasePackage.Literals.XCONSTRUCTOR_CALL__ARGUMENTS, nodes)) { acceptor.accept(constructorCallElements.getArgumentsXShortClosureParserRuleCall_4_1_0_0(), arguments.get(0), 0); acceptor.accept(constructorCallElements.getArgumentsXClosureParserRuleCall_5_0(), arguments.get(1), 1); } else if (constructorCall.isExplicitConstructorCall() && isXShortClosure(constructorCall, XbasePackage.Literals.XCONSTRUCTOR_CALL__ARGUMENTS, nodes)) { acceptor.accept(constructorCallElements.getArgumentsXShortClosureParserRuleCall_4_1_0_0(), arguments.get(0), 0); } else { diff = 1; if (constructorCall.isExplicitConstructorCall()) { if (arguments.size() - diff > 0) acceptor.accept(constructorCallElements.getArgumentsXExpressionParserRuleCall_4_1_1_0_0(), arguments.get(0), 0);
IResolvedTypes resolvedTypes = batchTypeResolver.resolveTypes(expr); List<LightweightTypeReference> typeArguments = resolvedTypes.getActualTypeArguments(expr); JvmConstructor constructor = expr.getConstructor(); List<JvmTypeParameter> constructorTypeParameters = constructor.getTypeParameters(); boolean hasTypeArguments = !typeArguments.isEmpty() && (featureLinkHelper.getDeclaredTypeParameters(constructor).size() == typeArguments.size()); List<JvmTypeReference> explicitTypeArguments = expr.getTypeArguments(); List<LightweightTypeReference> constructorTypeArguments = Collections.emptyList(); if (hasTypeArguments) { if (hasTypeArguments || (expr.isAnonymousClassConstructorCall() && !explicitTypeArguments.isEmpty() && ((JvmGenericType) constructor.getDeclaringType()).isAnonymous())) { if (typeArguments.isEmpty()) { LightweightTypeReference createdType = resolvedTypes.getActualType(expr); appendArguments(expr.getArguments(), b); b.append(")");
@Override protected void _toJavaStatement(final XConstructorCall expr, ITreeAppendable b, final boolean isReferenced) { for (XExpression arg : expr.getArguments()) { prepareExpression(arg, b); b.newLine(); constructorCallToJavaExpression(expr, b); if (expr.eContainer() instanceof AnonymousClass) { JvmConstructor constructor = expr.getConstructor(); JvmDeclaredType declaringType = constructor.getDeclaringType(); compileAnonymousClassBody((AnonymousClass) expr.eContainer(), declaringType, b);
protected IConstructorLinkingCandidate getKnownConstructor(XConstructorCall constructorCall, AbstractTypeComputationState state, ResolvedTypes resolvedTypes) { IConstructorLinkingCandidate result = resolvedTypes.getConstructor(constructorCall); if (result != null) { return result; } EObject proxyOrResolved = (EObject) constructorCall.eGet(XbasePackage.Literals.XCONSTRUCTOR_CALL__CONSTRUCTOR, false); if (proxyOrResolved == null) { result = new NullConstructorLinkingCandidate(constructorCall, state); return result; } if (!proxyOrResolved.eIsProxy()) { result = state.createResolvedLink(constructorCall, (JvmConstructor) proxyOrResolved); return result; } if (!encoder.isCrossLinkFragment(constructorCall.eResource(), EcoreUtil.getURI(proxyOrResolved).fragment())) { JvmConstructor constructor = constructorCall.getConstructor(); if (!constructor.eIsProxy()) { return state.createResolvedLink(constructorCall, constructor); } } return null; }
Function1<? super FormattableDocument, ? extends Iterable<FormattingData>> _prepend = this._formattingDataFactory.prepend(this._nodeModelAccess.nodeForFeature(expr, XbasePackage.Literals.XCONSTRUCTOR_CALL__CONSTRUCTOR), _function); format.operator_add(_prepend); boolean _isEmpty = expr.getTypeArguments().isEmpty(); boolean _not = (!_isEmpty); if (_not) { Function1<? super FormattableDocument, ? extends Iterable<FormattingData>> _surround = this._formattingDataFactory.surround(this._nodeModelAccess.nodeForKeyword(expr, "<"), _function_1); format.operator_add(_surround); EList<JvmTypeReference> _typeArguments = expr.getTypeArguments(); for (final JvmTypeReference arg : _typeArguments) { boolean _isMultiParamInOwnLine = this.isMultiParamInOwnLine(expr, format); if (_isMultiParamInOwnLine) { this.formatFeatureCallParamsMultiline(open, expr.getArguments(), format); } else { this.formatFeatureCallParamsWrapIfNeeded(open, expr.getArguments(), format);
@Override public List<IConstructorLinkingCandidate> getLinkingCandidates(XConstructorCall constructorCall) { IConstructorLinkingCandidate result = reentrantTypeResolver.getScopeProviderAccess().getKnownConstructor(constructorCall, this, resolvedTypes); if(result != null) { return Collections.singletonList(result); } EObject proxyOrResolved = (EObject) constructorCall.eGet(XbasePackage.Literals.XCONSTRUCTOR_CALL__CONSTRUCTOR, false); Iterable<IEObjectDescription> descriptions = reentrantTypeResolver.getScopeProviderAccess().getCandidateDescriptions( constructorCall, XbasePackage.Literals.XCONSTRUCTOR_CALL__CONSTRUCTOR, proxyOrResolved, featureScopeSession, resolvedTypes); List<IConstructorLinkingCandidate> resultList = Lists.newArrayList(); for(IEObjectDescription description: descriptions) { resultList.add(createCandidate(constructorCall, toIdentifiableDescription(description))); } if (resultList.isEmpty()) { resultList.add(new NullConstructorLinkingCandidate(constructorCall, this)); } return resultList; }
@Override protected IScope doCreateConstructorCallSerializationScope(XConstructorCall context) { if (context.eContainer() instanceof AnonymousClass) { final AnonymousClass anonymousClass = (AnonymousClass) context.eContainer(); final JvmType superType = anonymousClassUtil.getSuperType(anonymousClass); if(superType != null) { return createAnonymousClassConstructorScope(context, superType); } } return super.doCreateConstructorCallSerializationScope(context); }
if (container.get() instanceof XConstructorCall) { final XConstructorCall cons = (XConstructorCall) container.get(); arguments = cons.getArguments(); final JvmConstructor constructor = cons.getConstructor(); parameters = getParamTypeReferences(constructor, false, true); hasSideEffects = false;
/** * Syntax: '('* */ @Override protected void emit_XParenthesizedExpression_LeftParenthesisKeyword_0_a(EObject semanticObject, ISynNavigable transition, List<INode> nodes) { Keyword kw = grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0(); if (nodes == null) { if (semanticObject instanceof XIfExpression || semanticObject instanceof XTryCatchFinallyExpression) { EObject cnt = semanticObject.eContainer(); if (cnt instanceof XExpression && !(cnt instanceof XBlockExpression) && !(cnt instanceof XForLoopExpression)) acceptUnassignedKeyword(kw, kw.getValue(), null); } if (semanticObject instanceof XConstructorCall) { XConstructorCall call = (XConstructorCall) semanticObject; if (!call.isExplicitConstructorCall() && call.getArguments().isEmpty()) { acceptUnassignedKeyword(kw, kw.getValue(), null); } } } acceptNodes(transition, nodes); }
}; format.prepend(this.textRegionExtensions.regionFor(expr).feature(XbasePackage.Literals.XCONSTRUCTOR_CALL__CONSTRUCTOR), _function); boolean _isEmpty = expr.getTypeArguments().isEmpty(); boolean _not = (!_isEmpty); if (_not) { }; format.surround(this.textRegionExtensions.regionFor(expr).keyword("<"), _function_1); EList<JvmTypeReference> _typeArguments = expr.getTypeArguments(); for (final JvmTypeReference arg : _typeArguments) { }; format.prepend(open, _function_3); this.formatFeatureCallParams(expr.getArguments(), open, close, format);
public JvmDeclaredType getSuperTypeNonResolving(AnonymousClass anonymousClass, IScope typeScope) { XConstructorCall constructorCall = anonymousClass.getConstructorCall(); EObject constructorProxy = (EObject) constructorCall.eGet(XbasePackage.Literals.XCONSTRUCTOR_CALL__CONSTRUCTOR, false); IEObjectDescription description = null; if (constructorProxy != null) { if (!constructorProxy.eIsProxy()) { return getSuperType(anonymousClass); } String fragment = EcoreUtil.getURI(constructorProxy).fragment(); INode node = uriEncoder.getNode(constructorCall, fragment); String name = linkingHelper.getCrossRefNodeAsString(node, true); QualifiedName superTypeName = qualifiedNameConverter.toQualifiedName(name); description = typeScope.getSingleElement(superTypeName); } if (description == null || !EcoreUtil2.isAssignableFrom(TypesPackage.Literals.JVM_DECLARED_TYPE, description.getEClass())) { description = typeScope.getSingleElement(QualifiedName.create("java", "lang", "Object")); } if (description != null && EcoreUtil2.isAssignableFrom(TypesPackage.Literals.JVM_DECLARED_TYPE, description.getEClass())) { JvmDeclaredType type = (JvmDeclaredType) description.getEObjectOrProxy(); if (!type.eIsProxy()) return type; return (JvmDeclaredType) EcoreUtil.resolve(type, anonymousClass); } return null; }
protected void highlightConstructorCall(XConstructorCall constructorCall, IHighlightedPositionAcceptor acceptor) { if (constructorCall.getConstructor() != null && !constructorCall.getConstructor().eIsProxy()) { EObject declaringType = constructorCall.getConstructor().getDeclaringType(); if (declaringType instanceof JvmGenericType) { highlightFeature(acceptor, constructorCall, XbasePackage.Literals.XCONSTRUCTOR_CALL__CONSTRUCTOR, getStyle((JvmGenericType) declaringType)); } } }
@Override protected List<XExpression> getArguments() { return getConstructorCall().getArguments(); }
/** * Syntax: '('* */ @Override protected void emit_XParenthesizedExpression_LeftParenthesisKeyword_0_a(EObject semanticObject, ISynNavigable transition, List<INode> nodes) { Keyword kw = grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0(); if (nodes == null) { if (semanticObject instanceof XIfExpression || semanticObject instanceof XTryCatchFinallyExpression) { EObject cnt = semanticObject.eContainer(); if (cnt instanceof XExpression && !(cnt instanceof XBlockExpression) && !(cnt instanceof XForLoopExpression)) acceptUnassignedKeyword(kw, kw.getValue(), null); } if (semanticObject instanceof XConstructorCall) { XConstructorCall call = (XConstructorCall) semanticObject; if (!call.isExplicitConstructorCall() && call.getArguments().isEmpty()) { acceptUnassignedKeyword(kw, kw.getValue(), null); } } } acceptNodes(transition, nodes); }