Method _parseFunctionDef

server/src/parser/parser.ts:507–551

(asyncToken?: KeywordToken, decorators?: DecoratorNode[])

    // funcdef: 'def' NAME parameters ['->' test] ':' suite
    // parameters: '(' [typedargslist] ')'
    private _parseFunctionDef(asyncToken?: KeywordToken, decorators?: DecoratorNode[]): FunctionNode {
        let defToken = this._getKeywordToken(KeywordType.Def);

        let nameToken = this._getTokenIfIdentifier();
        if (!nameToken) {
            this._addError('Expected function name after "def"', defToken);
            nameToken = new IdentifierToken(0, 0, '');
        }

        if (!this._consumeTokenIfType(TokenType.OpenParenthesis)) {
            this._addError('Expected "("', this._peekToken());
        }

        let paramList = this._parseVarArgsList(TokenType.CloseParenthesis, true);

        if (!this._consumeTokenIfType(TokenType.CloseParenthesis)) {
            this._addError('Expected ")"', this._peekToken());
        }

        let returnType: ExpressionNode | undefined;
        if (this._consumeTokenIfType(TokenType.Arrow)) {
            returnType = this._parseTestExpression();
        }

        let suite = this._parseSuite();

        let functionNode = new FunctionNode(defToken, new NameNode(nameToken), suite);
        if (asyncToken) {
            functionNode.isAsync = true;
            functionNode.extend(asyncToken);
        }
        functionNode.parameters = paramList;
        if (decorators) {
            functionNode.decorators = decorators;
            if (decorators.length > 0) {
                functionNode.extend(decorators[0]);
            }
        }
        if (returnType) {
            functionNode.returnTypeAnnotation = this._parseTypeAnnotation(returnType);
            functionNode.extend(functionNode.returnTypeAnnotation.rawExpression);
        }

        return functionNode;
    }

    // typedargslist: (
    //   tfpdef ['=' test] (',' tfpdef ['=' test])*