parse.bal

// Parse one file in a module
import wso2/nballerina.comm.err;
import wso2/nballerina.comm.diagnostic as d;

public type FilePath record {|
    string filename;
    string? directory = ();
|};

public readonly class ScannedModulePart {
    private TokenizerState tokState;
    public ImportDecl[] importDecls;
    int partIndex; 

    function init(ImportDecl[] decls, Tokenizer tok, int partIndex) {
        self.importDecls = decls.cloneReadOnly();
        self.tokState = tok.save();
        self.partIndex = partIndex;
    }

    function tokenizer() returns Tokenizer {
        Tokenizer tok = new(self.tokState.file);
        tok.restore(self.tokState);
        return tok;
    }

    public function sourceFile() returns SourceFile {
        return self.tokState.file;
    }
}

public function scanModulePart(SourceFile file, int partIndex) returns ScannedModulePart|err:Syntax {
    Tokenizer tok = new (file);
    check tok.advance();
    return new(check parseImportDecls(tok, partIndex), tok, partIndex);
}

public function parseModulePart(ScannedModulePart scanned) returns ModulePart|err:Syntax {
    Tokenizer tok = scanned.tokenizer();
    ModuleLevelDefn[] defns = [];
    ModulePart part = {
        file: scanned.sourceFile(),
        partIndex: scanned.partIndex,
        defns,
        importDecls: scanned.importDecls
    };
    while tok.current() != () {
        defns.push(check parseModuleDecl(tok, part));
    }
    return part;
}

public function parseExpression(SourceFile file) returns Expr|err:Syntax {
    Tokenizer tok = new (file);
    check tok.advance();
    Expr expr = check parseExpr(tok);
    if tok.current() != () {
        return parseError(tok, "unexpected input after expression");
    }
    return expr;
}

function parseImportDecls(Tokenizer tok, int partIndex) returns ImportDecl[]|err:Syntax {
    ImportDecl[] imports = [];
    Token? t = tok.current();
    while t == "import" {
        ImportDecl im = check parseImportDecl(tok, partIndex);
        imports.push(im);
        t = tok.current();
    }
    return imports;
}

function parseImportDecl(Tokenizer tok, int partIndex) returns ImportDecl|err:Syntax {
    Position startPos = tok.currentStartPos();
    check tok.advance();
    Position namePos = tok.currentStartPos();
    string firstModuleName = check validImportPart(tok);
    string? org = ();
    if tok.current() == "/" {
        // we have an org
        org = firstModuleName;
        check tok.advance();
        namePos = tok.currentStartPos();
        firstModuleName = check validImportPart(tok);
    }
    [string, string...] names = [firstModuleName];
    names.push(...check parseImportNamesRest(tok));
    string? prefix = check parseImportPrefix(tok);
    Position endPos = check tok.expectEnd(";");
    return { startPos, endPos, org, names, prefix, namePos, partIndex };
}

function parseImportNamesRest(Tokenizer tok) returns string[]|err:Syntax {
    string[] names = [];
    while tok.current() == "." {
        check tok.advance();
        names.push(check validImportPart(tok));
    }
    return names;
}

function validImportPart(Tokenizer tok) returns string|err:Syntax {
    string identifier = check tok.expectIdentifier();
    string? prevChar = ();
    foreach var ch in identifier {
        if ch == "_" {
            if prevChar == () {
                return tok.err("identifier in an import must not have leading underscores");
            } else if prevChar == "_" {
                return tok.err("identifier in an import must not have consecutive underscores");
            }
        }
        prevChar = ch;
    }
    if prevChar == "_" {
        return tok.err("identifier in an import must not have tailing underscores");
    }
    return identifier;
}

function parseImportPrefix(Tokenizer tok) returns string?|err:Syntax {
    Token? t = tok.current();
    if t != "as" {
        return ();
    }
    check tok.advance();
    return tok.expectIdentifier();
}

function parseModuleDecl(Tokenizer tok, ModulePart part) returns ModuleLevelDefn|err:Syntax {
    Token? t = tok.current();
    Position startPos = tok.currentStartPos();
    Visibility vis;
    if t == "public" {
        vis = t;
        check tok.advance();
        t = tok.current();
    }
    else {
        vis = ();
    }
    match t {
        "type" => {
            return parseTypeDefinition(tok, part, vis, startPos);
        }
        "const" => {
            return parseConstDefinition(tok, part, vis, startPos);
        }
        "function" => {
            return parseFunctionDefinition(tok, part, vis, startPos);
        }
    }
    return parseError(tok);
}

function parseTypeDefinition(Tokenizer tok, ModulePart part, Visibility vis, Position startPos) returns TypeDefn|err:Syntax {
    check tok.advance();
    Position namePos = tok.currentStartPos();
    string name = check tok.expectIdentifier();
    TypeDesc td = check parseTypeDesc(tok);
    Position endPos = check tok.expectEnd(";");
    return { startPos, endPos, name, td, namePos, vis, part };
}

function parseConstDefinition(Tokenizer tok, ModulePart part, Visibility vis, Position startPos) returns ConstDefn|err:Syntax {
    check tok.advance();
    Token? t = tok.current();
    SubsetBuiltinTypeDesc? td = ();
    if t is SubsetBuiltinTypeName {
        Position tdStartPos = tok.currentStartPos();
        Position tdEndPos = tok.currentEndPos();
        check tok.advance();
        td = { startPos: tdStartPos, endPos: tdEndPos, builtinTypeName: t };
    }
    Position namePos = tok.currentStartPos();
    string name = check tok.expectIdentifier();
    check tok.expect("=");
    Expr expr = check parseExpr(tok);
    Position endPos = check tok.expectEnd(";");
    return { startPos, endPos, td, name, expr, namePos, vis, part };
}

function parseFunctionDefinition(Tokenizer tok, ModulePart part, Visibility vis, Position startPos) returns FunctionDefn|err:Syntax {
    check tok.advance();
    Position namePos = tok.currentStartPos();
    string name = check tok.expectIdentifier();
    FunctionParam [] params = [];
    FunctionTypeDesc typeDesc = check parseFunctionTypeDesc(tok, params);
    StmtBlock body = check parseStmtBlock(tok);
    Position endPos = tok.previousEndPos();
    FunctionDefn defn = { startPos, endPos, params, typeDesc, name, vis, namePos, body, part };
    return defn;
}

function parseError(Tokenizer tok, string? detail = ()) returns err:Syntax {
    string message = "parse error";
    Token? t = tok.current();
    if t is string {
        // XXX should use err:Template here
        message += " at '" + t + "'";
    }
    if detail != () {
        message += ": " + detail;
    }
    return tok.err(message);
}

public function defnLocation(ModuleLevelDefn defn) returns d:Location {
    return qNameLocationInDefn(defn, defn.namePos);
}

public function qNameLocationInDefn(ModuleLevelDefn defn, Position qnamePos) returns d:Location {
    return locationInDefn(defn, defn.part.file.qNameRange(qnamePos));
}

public function locationInDefn(ModuleLevelDefn defn, Position|Range pos) returns d:Location {
    return d:location(defn.part.file, pos);
}

public function range(record {| *PositionFields; any|error...; |} node) returns Range {
    return { startPos: node.startPos, endPos: node.endPos };
}