private FormalParameterListTree parseSetterParameterList() { FormalParameterListTree parameterList = parseFormalParameterList(ParamContext.IMPLEMENTATION); if (parameterList.parameters.size() != 1) { reportError( parameterList, "Setter must have exactly 1 parameter, found %d", parameterList.parameters.size()); } if (parameterList.parameters.size() >= 1) { ParseTree parameter = parameterList.parameters.get(0); if (parameter.isRestParameter()) { reportError(parameter, "Setter must not have a rest parameter"); } } return parameterList; }
private FormalParameterListTree transformArrowFunctionParameters( SourcePosition start, ParseTree tree) { switch (tree.type) { case IDENTIFIER_EXPRESSION: return new FormalParameterListTree( getTreeLocation(start), ImmutableList.<ParseTree>of(tree)); case PAREN_EXPRESSION: resetScanner(tree); // If we fail to parse as an ArrowFunction paramater list then // parseFormalParameterList will take care reporting errors. return parseFormalParameterList(ParamContext.IMPLEMENTATION); case FORMAL_PARAMETER_LIST: return tree.asFormalParameterList(); default: reportError("invalid arrow function parameters"); return null; } }
private FunctionDeclarationTree parseFunctionTail( SourcePosition start, IdentifierToken name, boolean isStatic, boolean isGenerator, TokenType access, FunctionDeclarationTree.Kind kind) { inGeneratorContext.addLast(isGenerator); GenericTypeListTree generics = maybeParseGenericTypes(); FormalParameterListTree formalParameterList = parseFormalParameterList(ParamContext.IMPLEMENTATION); ParseTree returnType = maybeParseColonType(); BlockTree functionBody = parseFunctionBody(); FunctionDeclarationTree declaration = new FunctionDeclarationTree( getTreeLocation(start), name, generics, isStatic, isGenerator, false, access, kind, formalParameterList, returnType, functionBody); inGeneratorContext.removeLast(); return declaration; }
private FormalParameterListTree transformToArrowFormalParameters(ParseTree leftOfArrow) { FormalParameterListTree arrowParameterList; switch (leftOfArrow.type) { case FORMAL_PARAMETER_LIST: arrowParameterList = leftOfArrow.asFormalParameterList(); break; case IDENTIFIER_EXPRESSION: // e.g. x => x + 1 arrowParameterList = new FormalParameterListTree( leftOfArrow.location, ImmutableList.<ParseTree>of(leftOfArrow)); break; case ARGUMENT_LIST: case PAREN_EXPRESSION: // e.g. (x) => x + 1 resetScanner(leftOfArrow); // If we fail to parse as an ArrowFunction parameter list then // parseFormalParameterList will take care of reporting errors. arrowParameterList = parseFormalParameterList(ParamContext.IMPLEMENTATION); break; default: reportError(leftOfArrow, "invalid arrow function parameters"); arrowParameterList = newEmptyFormalParameterList(leftOfArrow.location); } return arrowParameterList; }
private CallSignatureTree parseCallSignature(boolean isNew) { SourcePosition start = getTreeStartLocation(); if (isNew) { eat(TokenType.NEW); } GenericTypeListTree generics = maybeParseGenericTypes(); FormalParameterListTree params = parseFormalParameterList(ParamContext.SIGNATURE); ParseTree returnType = maybeParseColonType(); return new CallSignatureTree(getTreeLocation(start), isNew, generics, params, returnType); }
private CallSignatureTree parseCallSignature(boolean isNew) { SourcePosition start = getTreeStartLocation(); if (isNew) { eat(TokenType.NEW); } GenericTypeListTree generics = maybeParseGenericTypes(); FormalParameterListTree params = parseFormalParameterList(ParamContext.SIGNATURE); ParseTree returnType = maybeParseColonType(); return new CallSignatureTree(getTreeLocation(start), isNew, generics, params, returnType); }
private FunctionDeclarationTree parseAmbientFunctionDeclaration(SourcePosition start, IdentifierToken name, boolean isGenerator) { GenericTypeListTree generics = maybeParseGenericTypes(); FormalParameterListTree formalParameterList = parseFormalParameterList(ParamContext.SIGNATURE); ParseTree returnType = maybeParseColonType(); ParseTree functionBody = new EmptyStatementTree(getTreeLocation(start)); FunctionDeclarationTree declaration = new FunctionDeclarationTree( getTreeLocation(start), name, generics, false, isGenerator, false, null, FunctionDeclarationTree.Kind.DECLARATION, formalParameterList, returnType, functionBody); return declaration; }
private FunctionDeclarationTree parseMethodSignature(SourcePosition start, IdentifierToken name, boolean isStatic, boolean isGenerator, boolean isOptional, TokenType access) { GenericTypeListTree generics = maybeParseGenericTypes(); FormalParameterListTree formalParameterList = parseFormalParameterList(ParamContext.SIGNATURE); ParseTree returnType = maybeParseColonType(); ParseTree functionBody = new EmptyStatementTree(getTreeLocation(start)); FunctionDeclarationTree declaration = new FunctionDeclarationTree( getTreeLocation(start), name, generics, isStatic, isGenerator, isOptional, access, FunctionDeclarationTree.Kind.MEMBER, formalParameterList, returnType, functionBody); return declaration; }
private void parseFunctionTail( FunctionDeclarationTree.Builder builder, FunctionFlavor functionFlavor) { functionContextStack.addLast(functionFlavor); builder .setGenerator(functionFlavor.isGenerator) .setGenerics(maybeParseGenericTypes()) .setFormalParameterList(parseFormalParameterList(ParamContext.IMPLEMENTATION)) .setReturnType(maybeParseColonType()) .setFunctionBody(parseFunctionBody()); functionContextStack.removeLast(); }
private ParseTree parseFunctionTypeExpression() { SourcePosition start = getTreeStartLocation(); ParseTree typeExpression = null; if (peekFunctionTypeExpression()) { FormalParameterListTree formalParameterList; formalParameterList = parseFormalParameterList(ParamContext.IMPLEMENTATION); eat(TokenType.ARROW); ParseTree returnType = parseType(); typeExpression = new FunctionTypeTree( getTreeLocation(start), formalParameterList, returnType); } else { typeExpression = parseArrayTypeExpression(); } return typeExpression; }
private ParseTree parseFunctionTypeExpression() { SourcePosition start = getTreeStartLocation(); ParseTree typeExpression = null; if (peekFunctionTypeExpression()) { FormalParameterListTree formalParameterList; formalParameterList = parseFormalParameterList(ParamContext.IMPLEMENTATION); eat(TokenType.ARROW); ParseTree returnType = parseType(); typeExpression = new FunctionTypeTree( getTreeLocation(start), formalParameterList, returnType); } else { typeExpression = parseArrayTypeExpression(); } return typeExpression; }
private boolean peekFunctionTypeExpression() { if ((config.parseTypeSyntax && peek(TokenType.OPEN_PAREN)) || peek(TokenType.OPEN_ANGLE)) { // TODO(blickly): determine if we can parse this without the // overhead of forking the parser. Parser p = createLookaheadParser(); try { p.maybeParseGenericTypes(); p.parseFormalParameterList(ParamContext.TYPE_EXPRESSION); if (p.peek(TokenType.COLON)) { p.parseTypeAnnotation(); } return p.peek(TokenType.ARROW); } catch (ParseException e) { return false; } } return false; }
private boolean peekFunctionTypeExpression() { if (peek(TokenType.OPEN_PAREN) || peek(TokenType.OPEN_ANGLE)) { // TODO(blickly): determine if we can parse this without the // overhead of forking the parser. Parser p = createLookaheadParser(); try { p.maybeParseGenericTypes(); p.parseFormalParameterList(ParamContext.TYPE_EXPRESSION); if (p.peek(TokenType.COLON)) { p.parseTypeAnnotation(); } return p.peek(TokenType.ARROW); } catch (ParseException e) { return false; } } return false; }
private FunctionDeclarationTree parseAmbientFunctionDeclaration( SourcePosition start, IdentifierToken name, boolean isGenerator) { FunctionDeclarationTree.Builder builder = FunctionDeclarationTree.builder(FunctionDeclarationTree.Kind.DECLARATION) .setName(name) .setGenerator(isGenerator) .setGenerics(maybeParseGenericTypes()) .setFormalParameterList(parseFormalParameterList(ParamContext.SIGNATURE)) .setReturnType(maybeParseColonType()) .setFunctionBody(new EmptyStatementTree(getTreeLocation(start))); return builder.build(getTreeLocation(start)); }
private ParseTree parseAsyncArrowFunction(Expression expressionIn) { SourcePosition start = getTreeStartLocation(); eatPredefinedString(ASYNC); if (peekImplicitSemiColon()) { reportError("No newline allowed between `async` and arrow function parameter list"); } FormalParameterListTree arrowParameterList = null; if (peek(TokenType.OPEN_PAREN)) { // async (...) => arrowParameterList = parseFormalParameterList(ParamContext.IMPLEMENTATION); } else { // async arg => final IdentifierExpressionTree singleParameter = parseIdentifierExpression(); arrowParameterList = new FormalParameterListTree( singleParameter.location, ImmutableList.<ParseTree>of(singleParameter)); } if (peekImplicitSemiColon()) { reportError("No newline allowed before '=>'"); } eat(TokenType.ARROW); ParseTree arrowFunctionBody = parseArrowFunctionBody(expressionIn, FunctionFlavor.ASYNCHRONOUS); FunctionDeclarationTree.Builder builder = FunctionDeclarationTree.builder(FunctionDeclarationTree.Kind.ARROW) .setAsync(true) .setFormalParameterList(arrowParameterList) .setFunctionBody(arrowFunctionBody); return builder.build(getTreeLocation(start)); }
private FunctionDeclarationTree parseMethodSignature( SourcePosition start, IdentifierToken name, boolean isStatic, boolean isGenerator, boolean isOptional, TokenType access) { FunctionDeclarationTree.Builder builder = FunctionDeclarationTree.builder(FunctionDeclarationTree.Kind.MEMBER) .setName(name) .setStatic(isStatic) .setGenerator(isGenerator) .setOptional(isOptional) .setAccess(access) .setGenerics(maybeParseGenericTypes()) .setFormalParameterList(parseFormalParameterList(ParamContext.SIGNATURE)) .setReturnType(maybeParseColonType()) .setFunctionBody(new EmptyStatementTree(getTreeLocation(start))); return builder.build(getTreeLocation(start)); }
builder .setGenerics(maybeParseGenericTypes()) .setFormalParameterList(parseFormalParameterList(ParamContext.SIGNATURE)) .setReturnType(maybeParseColonType()) .setFunctionBody(new EmptyStatementTree(getTreeLocation(partial.start)));