static void addCreateParameterProposal( Collection<ICompletionProposal> proposals, String def, String desc, Image image, Declaration dec, PhasedUnit unit, Tree.Declaration decNode, Tree.ParameterList paramList, ProducedType t) { IFile file = CeylonBuilder.getFile(unit); TextFileChange change = new TextFileChange("Add Parameter", file); change.setEdit(new MultiTextEdit()); int offset = paramList.getStopIndex(); int il = importType(change, t, unit.getCompilationUnit()); change.addEdit(new InsertEdit(offset, def)); proposals.add( new CreateProposal( def, "Add " + desc + " to '" + dec.getName() + "'", image, 0, offset + il, file, change)); }
/** * Generates the code for single or multiple parameter lists, with a callback function to generate * the function blocks. */ static void generateParameterLists( final Node context, final List<Tree.ParameterList> plist, final Scope scope, final ParameterListCallback callback, final boolean emitFunctionKeyword, final GenerateJsVisitor gen) { if (plist.size() == 1) { if (emitFunctionKeyword) { gen.out("function"); } Tree.ParameterList paramList = plist.get(0); paramList.visit(gen); callback.completeFunction(); } else { List<MplData> metas = new ArrayList<>(plist.size()); Function m = scope instanceof Function ? (Function) scope : null; for (Tree.ParameterList paramList : plist) { final MplData mpl = new MplData(); metas.add(mpl); mpl.n = context; if (metas.size() == 1) { if (emitFunctionKeyword) { gen.out("function"); } } else { mpl.name = gen.getNames().createTempVariable(); mpl.params = paramList; gen.out("var ", mpl.name, "=function"); } paramList.visit(gen); if (metas.size() == 1) { gen.beginBlock(); gen.initSelf(context); Scope parent = scope == null ? null : scope.getContainer(); gen.initParameters( paramList, parent instanceof TypeDeclaration ? (TypeDeclaration) parent : null, m); } else { gen.out("{"); } } callback.completeFunction(); closeMPL(metas, m.getType(), gen); gen.endBlock(); } }
Type tupleFromParameterList() { if (params.getParameters().isEmpty()) { return n.getUnit().getEmptyType(); } List<Type> types = new ArrayList<>(params.getParameters().size()); int firstDefaulted = -1; int count = 0; for (Tree.Parameter p : params.getParameters()) { types.add(p.getParameterModel().getType()); if (p.getParameterModel().isDefaulted()) firstDefaulted = count; count++; } return n.getUnit() .getTupleType( types, params .getParameters() .get(params.getParameters().size() - 1) .getParameterModel() .isSequenced(), params .getParameters() .get(params.getParameters().size() - 1) .getParameterModel() .isAtLeastOne(), firstDefaulted); }
public JCNewClass build() { // Generate a subclass of Callable ListBuffer<JCTree> classBody = new ListBuffer<JCTree>(); int numParams = paramLists.getParameters().size(); int minimumParams = 0; for (Parameter p : paramLists.getParameters()) { if (p.isDefaulted() || p.isSequenced()) break; minimumParams++; } boolean isVariadic = minimumParams != numParams; if (parameterListTree != null) { // generate a method for each defaulted param for (Tree.Parameter p : parameterListTree.getParameters()) { if (p.getDefaultArgument() != null || p.getDeclarationModel().isSequenced()) { MethodDefinitionBuilder methodBuilder = gen.classGen().makeParamDefaultValueMethod(false, null, parameterListTree, p); classBody.append(methodBuilder.build()); } } } // collect each parameter type from the callable type model rather than the declarations to get // them all bound java.util.List<ProducedType> parameterTypes = new ArrayList<ProducedType>(numParams); if (forwardCallTo != null) { for (int i = 0; i < numParams; i++) parameterTypes.add(gen.getParameterTypeOfCallable(typeModel, i)); } else { // get them from our declaration for (Parameter p : paramLists.getParameters()) parameterTypes.add(p.getType()); } // now generate a method for each supported minimum number of parameters below 4 // which delegates to the $call$typed method if required for (int i = minimumParams, max = Math.min(numParams, 4); i < max; i++) { classBody.append(makeDefaultedCall(i, isVariadic, parameterTypes)); } // generate the $call method for the max number of parameters, // which delegates to the $call$typed method if required classBody.append(makeDefaultedCall(numParams, isVariadic, parameterTypes)); // generate the $call$typed method if required if (isVariadic && forwardCallTo == null) classBody.append(makeCallTypedMethod(body, parameterTypes)); JCClassDecl classDef = gen.make().AnonymousClassDef(gen.make().Modifiers(0), classBody.toList()); JCNewClass instance = gen.make() .NewClass( null, null, gen.makeJavaType(typeModel, JT_EXTENDS | JT_CLASS_NEW), List.<JCExpression>of(gen.make().Literal(typeModel.getProducedTypeName(true))), classDef); return instance; }
void outputMetamodelAndReturn(GenerateJsVisitor gen, Type t) { gen.out(name, ".$crtmm$=function(){return{", MetamodelGenerator.KEY_PARAMS, ":"); TypeUtils.encodeParameterListForRuntime(true, n, params.getModel(), gen); if (t != null) { // Add the type to the innermost method gen.out(",", MetamodelGenerator.KEY_TYPE, ":"); TypeUtils.typeNameOrList(n, t, gen, false); } gen.out("};};return ", gen.getClAlias(), "jsc$3(0,", name, ");"); }
@Override public void visit(Tree.SpecifierStatement that) { if (that.getRefinement()) { Tree.Term lhs = that.getBaseMemberExpression(); if (lhs instanceof Tree.ParameterizedExpression) { Tree.ParameterizedExpression pe = (Tree.ParameterizedExpression) lhs; for (Tree.ParameterList pl : pe.getParameterLists()) { if (pl != null) { pl.visit(this); } } Tree.TypeParameterList tpl = pe.getTypeParameterList(); if (tpl != null) { tpl.visit(this); } } // the LHS will be treated as a refinement by // FindRefinementsVisitor so ignore it here super.visit(that.getSpecifierExpression()); } else { super.visit(that); } }
private static void parameters(Tree.ParameterList pl, StyledString label) { if (pl == null || pl.getParameters().isEmpty()) { label.append("()"); } else { label.append("("); int len = pl.getParameters().size(), i = 0; for (Tree.Parameter p : pl.getParameters()) { if (p != null) { label .append(type(p.getType()), TYPE_STYLER) .append(" ") .append(name(p.getIdentifier()), ID_STYLER); if (p instanceof Tree.FunctionalParameterDeclaration) { Tree.FunctionalParameterDeclaration fp = (Tree.FunctionalParameterDeclaration) p; for (Tree.ParameterList ipl : fp.getParameterLists()) { parameters(ipl, label); } } } if (++i < len) label.append(", "); } label.append(")"); } }
static void addCreateParameterAndAttributeProposal( Collection<ICompletionProposal> proposals, String pdef, String adef, String desc, Image image, Declaration dec, PhasedUnit unit, Tree.Declaration decNode, Tree.ParameterList paramList, Tree.Body body, ProducedType t) { IFile file = CeylonBuilder.getFile(unit); TextFileChange change = new TextFileChange("Add Attribute", file); change.setEdit(new MultiTextEdit()); int offset = paramList.getStopIndex(); IDocument doc = CreateProposal.getDocument(change); String indent; String indentAfter; int offset2; List<Tree.Statement> statements = body.getStatements(); if (statements.isEmpty()) { indentAfter = "\n" + CeylonQuickFixAssistant.getIndent(decNode, doc); indent = indentAfter + getDefaultIndent(); offset2 = body.getStartIndex() + 1; } else { Tree.Statement statement = statements.get(statements.size() - 1); indent = "\n" + CeylonQuickFixAssistant.getIndent(statement, doc); offset2 = statement.getStopIndex() + 1; indentAfter = ""; } int il = importType(change, t, unit.getCompilationUnit()); change.addEdit(new InsertEdit(offset, pdef)); change.addEdit(new InsertEdit(offset2, indent + adef + indentAfter)); proposals.add( new CreateProposal( pdef, "Add " + desc + " to '" + dec.getName() + "'", image, 0, offset + il, file, change)); }
static void methodDefinition( final Tree.MethodDefinition that, final GenerateJsVisitor gen, final boolean needsName, final boolean verboseStitcher) { final Function d = that.getDeclarationModel(); if (TypeUtils.isNativeExternal(d)) { if (gen.stitchNative(d, that)) { if (verboseStitcher) { gen.spitOut( "Stitching in native method " + d.getQualifiedNameString() + ", ignoring Ceylon definition"); } if (d.isShared()) { gen.share(d); } return; } } if (that.getParameterLists().size() == 1) { if (needsName) { gen.out(GenerateJsVisitor.function, gen.getNames().name(d)); } else { gen.out("function"); } Tree.ParameterList paramList = that.getParameterLists().get(0); paramList.visit(gen); gen.beginBlock(); if (d.getContainer() instanceof TypeDeclaration) { gen.initSelf(that); } addParentMethodTypeParameters(d, gen); gen.initParameters(paramList, null, d); gen.visitStatements(that.getBlock().getStatements()); gen.endBlock(); } else { List<MplData> metas = new ArrayList<>(that.getParameterLists().size()); for (Tree.ParameterList paramList : that.getParameterLists()) { final MplData mpl = new MplData(); mpl.n = that; metas.add(mpl); if (metas.size() == 1) { if (needsName) { gen.out(GenerateJsVisitor.function, gen.getNames().name(d)); } else { gen.out("function"); } } else { mpl.name = gen.getNames().createTempVariable(); mpl.params = paramList; gen.out("var ", mpl.name, "=function"); } paramList.visit(gen); gen.beginBlock(); if (metas.size() == 1 && d.getContainer() instanceof TypeDeclaration) { gen.initSelf(that); } gen.initParameters(paramList, null, d); } gen.visitStatements(that.getBlock().getStatements()); closeMPL(metas, d.getType(), gen); gen.endBlock(); } if (!gen.share(d)) { gen.out(";"); } }