@Override public String getFormalParameterName(int position) { return this.parameters.get(position).getName(); }
private boolean containsParam(final EList<JvmFormalParameter> params, final String param) { final Function1<JvmFormalParameter, String> _function = (JvmFormalParameter it) -> { return it.getName(); }; return ListExtensions.<JvmFormalParameter, String>map(params, _function).contains(param); }
protected String parametersToString(Iterable<? extends JvmFormalParameter> elements, boolean isVarArgs, boolean includeName) { StringBuilder result = new StringBuilder(); boolean needsSeparator = false; Iterator<? extends JvmFormalParameter> iterator = elements.iterator(); while (iterator.hasNext()) { JvmFormalParameter parameter = iterator.next(); if (needsSeparator) result.append(", "); needsSeparator = true; JvmTypeReference typeRef = parameter.getParameterType(); if (isVarArgs && !iterator.hasNext() && typeRef instanceof JvmGenericArrayTypeReference) { typeRef = ((JvmGenericArrayTypeReference) typeRef).getComponentType(); result.append(referenceToString(typeRef, "[null]")); result.append("..."); } else { result.append(referenceToString(typeRef, "[null]")); } if (includeName) { result.append(" " + parameter.getName()); } } return result.toString(); }
protected void initializeClosureParameters(IEvaluationContext context, Object[] args) { if (args.length != closure.getFormalParameters().size()) throw new IllegalStateException("Number of arguments did not match. Expected: " + closure.getFormalParameters().size() + " but was: " + args.length); int i = 0; for(JvmFormalParameter param: closure.getFormalParameters()) { context.newValue(QualifiedName.create(param.getName()), args[i]); i++; } }
protected void highlightFormalParameter(JvmFormalParameter parameterDecl, IHighlightedPositionAcceptor acceptor) { if (!SPECIAL_FEATURE_NAMES.contains(parameterDecl.getName())) { // highlighting of special identifiers is done separately, so it's omitted here if (parameterDecl.eContainingFeature() == XbasePackage.Literals.XCLOSURE__DECLARED_FORMAL_PARAMETERS) { highlightFeature(acceptor, parameterDecl, TypesPackage.Literals.JVM_FORMAL_PARAMETER__NAME, PARAMETER_VARIABLE); } else { // covers parameters of for and template expr FOR loops, as well as switch statements highlightFeature(acceptor, parameterDecl, TypesPackage.Literals.JVM_FORMAL_PARAMETER__NAME, LOCAL_VARIABLE_DECLARATION); highlightFeature(acceptor, parameterDecl, TypesPackage.Literals.JVM_FORMAL_PARAMETER__NAME, LOCAL_FINAL_VARIABLE_DECLARATION); } } }
protected void appendParameters(final StringBuilder result, final JvmExecutable executable, final int insignificantParameters, final LightweightTypeReferenceFactory ownedConverter) { final EList<JvmFormalParameter> declaredParameters = executable.getParameters(); final List<JvmFormalParameter> relevantParameters = declaredParameters.subList(Math.min(insignificantParameters, declaredParameters.size()), declaredParameters.size()); for (int i = 0; (i < relevantParameters.size()); i++) { { final JvmFormalParameter parameter = relevantParameters.get(i); if ((i != 0)) { result.append(", "); } if ((((i == (relevantParameters.size() - 1)) && executable.isVarArgs()) && (parameter.getParameterType() instanceof JvmGenericArrayTypeReference))) { JvmTypeReference _parameterType = parameter.getParameterType(); final JvmGenericArrayTypeReference parameterType = ((JvmGenericArrayTypeReference) _parameterType); result.append(ownedConverter.toLightweightReference(parameterType.getComponentType()).getHumanReadableName()); result.append("..."); } else { JvmTypeReference _parameterType_1 = parameter.getParameterType(); boolean _tripleNotEquals = (_parameterType_1 != null); if (_tripleNotEquals) { final String simpleName = ownedConverter.toLightweightReference(parameter.getParameterType()).getHumanReadableName(); if ((simpleName != null)) { result.append(simpleName); } } } result.append(" "); result.append(String.valueOf(parameter.getName())); } } }
return ((JvmFormalParameter) ex).getName();
public /* @Nullable */ String getSimpleName(JvmIdentifiableElement element) { if (element == null || element.eIsProxy()) { return null; } if (element instanceof JvmFeature) { return ((JvmFeature) element).getSimpleName(); } if (element instanceof JvmFormalParameter) { return ((JvmFormalParameter) element).getName(); } if (element instanceof XVariableDeclaration) { return ((XVariableDeclaration) element).getName(); } return element.getSimpleName(); } }
@Check public void checkLocalUsageOfSwitchParameter(XSwitchExpression switchExpression) { JvmFormalParameter switchParam = switchExpression.getDeclaredParam(); if(!isIgnored(UNUSED_LOCAL_VARIABLE) && switchParam != null && !isLocallyUsed(switchParam, switchExpression)){ String message = "The value of the local variable " + switchParam.getName() + " is not used"; addIssue(message, switchParam, TypesPackage.Literals.JVM_FORMAL_PARAMETER__NAME, UNUSED_LOCAL_VARIABLE); } }
protected Object _doEvaluate(XForLoopExpression forLoop, IEvaluationContext context, CancelIndicator indicator) { Object iterableOrIterator = internalEvaluate(forLoop.getForExpression(), context, indicator); if (iterableOrIterator == null) return throwNullPointerException(forLoop.getForExpression(), "iterable evaluated to 'null'"); Iterator<?> iter = null; if (iterableOrIterator instanceof Iterable<?>) { iter = ((Iterable<?>) iterableOrIterator).iterator(); } else if (iterableOrIterator.getClass().isArray()) { iter = ((Iterable<?>) Conversions.doWrapArray(iterableOrIterator)).iterator(); } else { return throwClassCastException(forLoop.getForExpression(), iterableOrIterator, java.lang.Iterable.class); } IEvaluationContext forkedContext = context.fork(); QualifiedName paramName = QualifiedName.create(forLoop.getDeclaredParam().getName()); forkedContext.newValue(paramName, null); while (iter.hasNext()) { Object next = iter.next(); forkedContext.assignValue(paramName, next); internalEvaluate(forLoop.getEachExpression(), forkedContext, indicator); } return null; }
protected void appendClosureParameter(JvmFormalParameter closureParam, LightweightTypeReference parameterType, ITreeAppendable appendable) { appendable.append("final "); appendable.append(parameterType); appendable.append(" "); final String proposedParamName = makeJavaIdentifier(closureParam.getName()); String name = appendable.declareVariable(closureParam, proposedParamName); appendable.append(name); }
protected void appendClosureParameterVarArgs(JvmFormalParameter closureParam, LightweightTypeReference parameterType, ITreeAppendable appendable) { appendable.append("final "); appendable.append(parameterType); appendable.append("... "); final String proposedParamName = makeJavaIdentifier(closureParam.getName()); String name = appendable.declareVariable(closureParam, proposedParamName); appendable.append(name); }
parameter.setParameterType(jvmTypesBuilder.inferredType()); JvmFormalParameter parameter2 = first.getParameters().get(i); parameter.setName(parameter2.getName());
final List<JvmFormalParameter> parameters = superConstructor.getParameters(); for(JvmFormalParameter parameter: parameters) { parameter.getName(); // trigger name computation constructor.getParameters().add(typesBuilder.cloneWithProxies(parameter));
protected void appendForLoopParameter(XForLoopExpression expr, ITreeAppendable appendable) { appendable.append("final "); JvmTypeReference paramType = getForLoopParameterType(expr); serialize(paramType, expr, appendable); appendable.append(" "); final String name = makeJavaIdentifier(expr.getDeclaredParam().getName()); String varName = appendable.declareVariable(expr.getDeclaredParam(), name); appendable.trace(expr.getDeclaredParam(), TypesPackage.Literals.JVM_FORMAL_PARAMETER__NAME, 0).append(varName); }
String proposedParamName = makeJavaIdentifier(closureParam.getName());
/** * Contexts: * FullJvmFormalParameter returns JvmFormalParameter * * Constraint: * (parameterType=JvmTypeReference name=ValidID) */ protected void sequence_FullJvmFormalParameter(ISerializationContext context, JvmFormalParameter semanticObject) { if (errorAcceptor != null) { if (transientValues.isValueTransient(semanticObject, TypesPackage.Literals.JVM_FORMAL_PARAMETER__PARAMETER_TYPE) == ValueTransient.YES) errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, TypesPackage.Literals.JVM_FORMAL_PARAMETER__PARAMETER_TYPE)); if (transientValues.isValueTransient(semanticObject, TypesPackage.Literals.JVM_FORMAL_PARAMETER__NAME) == ValueTransient.YES) errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, TypesPackage.Literals.JVM_FORMAL_PARAMETER__NAME)); } SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); feeder.accept(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0(), semanticObject.getParameterType()); feeder.accept(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0(), semanticObject.getName()); feeder.finish(); }
String loopParam = debugAppendable.declareVariable(parameter, parameter.getName()); debugAppendable.append(loopParam); debugAppendable.append(" : ");
protected void appendCatchClause(XCatchClause catchClause, boolean parentIsReferenced, String parentVariable, ITreeAppendable appendable) { JvmTypeReference type = catchClause.getDeclaredParam().getParameterType(); final String declaredParamName = makeJavaIdentifier(catchClause.getDeclaredParam().getName()); final String name = appendable.declareVariable(catchClause.getDeclaredParam(), declaredParamName); appendable.append("if (");
protected Object _doEvaluate(XTryCatchFinallyExpression tryCatchFinally, IEvaluationContext context, CancelIndicator indicator) { Object result = null; try { result = internalEvaluate(tryCatchFinally.getExpression(), context, indicator); } catch (EvaluationException evaluationException) { Throwable cause = evaluationException.getCause(); for (XCatchClause catchClause : tryCatchFinally.getCatchClauses()) { JvmFormalParameter exception = catchClause.getDeclaredParam(); JvmTypeReference catchParameterType = exception.getParameterType(); if (!isInstanceoOf(cause, catchParameterType)) { continue; } IEvaluationContext forked = context.fork(); forked.newValue(QualifiedName.create(exception.getName()), cause); result = internalEvaluate(catchClause.getExpression(), forked, indicator); break; } } if (tryCatchFinally.getFinallyExpression() != null) { try { internalEvaluate(tryCatchFinally.getFinallyExpression(), context, indicator); } catch (EvaluationException e) { throw new EvaluationException(new FinallyDidNotCompleteException(e)); } } return result; }