openalgo-script 0.1.0-alpha.0

package/dist/core/parse/names.d.ts

@@ -0,0 +1,34 @@
+import type { Name } from '../ast/index.js';
+import type { TokenKind } from '../tokens/index.js';
+import type { Cursor } from './cursor.js';
+/** Whether a token may stand where a word is expected. */
+export declare function isWordKind(kind: TokenKind): boolean;
+/** Whether a word standing where a value belongs is a name the language has taken. */
+export declare function isMeantAsAName(kind: TokenKind): boolean;
+/**
+ * The name at the cursor: an identifier, or a reserved word that is OS1019.
+ *
+ * The word is taken either way. A script that named something `type` still
+ * meant to declare it, and every later diagnostic about that name is more use
+ * to the reader than a hole where the declaration should have been.
+ */
+export declare function takeName(cursor: Cursor): Name;
+/**
+ * The label of a named argument, where a reserved word is legal.
+ *
+ * A label is matched against the callee's parameter list and is never looked up
+ * in a scope, so `plot(v, "V", color = aqua)` is correct and is not OS1019.
+ */
+export declare function takeLabel(cursor: Cursor): Name;
+/**
+ * The word after a dot.
+ *
+ * A member is matched against the namespace or the object type it was read
+ * from, which is the same kind of published list a label is matched against, so
+ * a reserved word is not OS1019 here either. Whether the member exists at all
+ * is OS2009, and the checker owns it.
+ */
+export declare function takeMember(cursor: Cursor): Name;
+/** Whether the cursor is on a named argument's label: a word, then a bare `=`. */
+export declare function atLabel(cursor: Cursor): boolean;
+//# sourceMappingURL=names.d.ts.map

package/dist/core/parse/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../../src/core/parse/names.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAiB1C,0DAA0D;AAC1D,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAEnD;AAqCD,sFAAsF;AACtF,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAEvD;AAuBD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAY7C;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAG9C;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE/C;AAED,kFAAkF;AAClF,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE/C"}

package/dist/core/parse/names.js

@@ -0,0 +1,122 @@
+import { makeNode } from '../ast/index.js';
+import { RESERVED_WORDS } from '../tokens/index.js';
+import { describeToken } from './cursor.js';
+/**
+ * Reading the places a name is written, which is where OS1019 lives.
+ *
+ * The lexer cannot make this call. A reserved word before an `=` is a legal
+ * label inside a call and is OS1019 inside a parameter list (language.md 3.4),
+ * and only the parser knows which of the two lists it is reading. So a reserved
+ * word arrives carrying its keyword kind, and the readers below are the
+ * answers: `takeName` refuses one, `takeLabel` and `takeMember` accept one,
+ * because a label and a member are matched against a published list rather than
+ * looked up in a scope.
+ */
+const RESERVED = new Set(RESERVED_WORDS);
+/** Whether a token may stand where a word is expected. */
+export function isWordKind(kind) {
+    return kind === 'identifier' || RESERVED.has(kind);
+}
+/**
+ * The reserved words a reader can only have meant as a name.
+ *
+ * A reserved word written where a value belongs is one of two things, and which
+ * one depends on the word. Six of them are read by a rule standing next to the
+ * expression: `and` and `or` join two operands and `not` takes one, and `in`,
+ * `to` and `step` are read by a `for` header the moment the expression before
+ * them ends. A word that opens a statement is the same answer again, because an
+ * unclosed bracket carries the statement onto the lines below it and the `if`
+ * down there belongs to its own line rather than to this expression. Taking any
+ * of those as a name would swallow a token the rule around it is waiting for,
+ * and the second diagnostic would then be about the rule rather than about the
+ * mistake.
+ *
+ * What is left is the four value type names, the two words that build a type,
+ * and the six the language reserves and version 1 does not implement. No rule
+ * of the grammar reads one of them anywhere near an expression, so a reader who
+ * wrote one where a value belongs wrote a name, and the answer is OS1019: the
+ * same answer `takeName` gives for the same word written as a target.
+ */
+const MEANT_AS_A_NAME = new Set([
+    'array',
+    'as',
+    'bool',
+    'color',
+    'import',
+    'is',
+    'map',
+    'matrix',
+    'number',
+    'series',
+    'string',
+    'type',
+]);
+/** Whether a word standing where a value belongs is a name the language has taken. */
+export function isMeantAsAName(kind) {
+    return MEANT_AS_A_NAME.has(kind);
+}
+/**
+ * A name that is not reserved, derived from one that is.
+ *
+ * OS1019 promises a near name that keeps the meaning, and the derivation has to
+ * work for all thirty six words rather than for the five anyone remembers, so
+ * it is mechanical: the word is what the reader meant, and the suffix is what
+ * makes it theirs to use.
+ */
+function unreservedNear(word) {
+    return `${word}Value`;
+}
+/** No word where one was required, which leaves the statement without its subject. */
+function missingWord(cursor) {
+    const hole = cursor.holeSpan();
+    cursor.report('OS1022', hole, {
+        token: describeToken(cursor.previousMeaningful() ?? cursor.token),
+    });
+    return makeNode('name', hole, { text: '' });
+}
+/**
+ * The name at the cursor: an identifier, or a reserved word that is OS1019.
+ *
+ * The word is taken either way. A script that named something `type` still
+ * meant to declare it, and every later diagnostic about that name is more use
+ * to the reader than a hole where the declaration should have been.
+ */
+export function takeName(cursor) {
+    const token = cursor.token;
+    if (!isWordKind(token.kind))
+        return missingWord(cursor);
+    cursor.advance();
+    if (token.kind !== 'identifier') {
+        cursor.report('OS1019', token.span, {
+            word: token.text,
+            suggestion: unreservedNear(token.text),
+        });
+    }
+    return makeNode('name', token.span, { text: token.text });
+}
+/**
+ * The label of a named argument, where a reserved word is legal.
+ *
+ * A label is matched against the callee's parameter list and is never looked up
+ * in a scope, so `plot(v, "V", color = aqua)` is correct and is not OS1019.
+ */
+export function takeLabel(cursor) {
+    const token = cursor.advance();
+    return makeNode('name', token.span, { text: token.text });
+}
+/**
+ * The word after a dot.
+ *
+ * A member is matched against the namespace or the object type it was read
+ * from, which is the same kind of published list a label is matched against, so
+ * a reserved word is not OS1019 here either. Whether the member exists at all
+ * is OS2009, and the checker owns it.
+ */
+export function takeMember(cursor) {
+    return isWordKind(cursor.kind) ? takeLabel(cursor) : missingWord(cursor);
+}
+/** Whether the cursor is on a named argument's label: a word, then a bare `=`. */
+export function atLabel(cursor) {
+    return isWordKind(cursor.kind) && cursor.peek().kind === '=';
+}
+//# sourceMappingURL=names.js.map

package/dist/core/parse/names.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.js","sourceRoot":"","sources":["../../../src/core/parse/names.ts"],"names":[],"mappings":"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"}

package/dist/core/parse/script.d.ts

@@ -0,0 +1,23 @@
+import type { Script } from '../ast/index.js';
+import type { DiagnosticSink } from '../diagnostics/index.js';
+import type { SourceFile } from '../source/index.js';
+import type { Token } from '../tokens/index.js';
+/**
+ * A file, which is a list of statements and function declarations.
+ *
+ * Section 19 writes a file as a version line, a declaration and a limits line
+ * followed by the rest. The prose wins: the declaration being missing is
+ * OS2007, two of them is OS2008, and a version line that is not first is
+ * OS1021, all of which name a line and suggest a move. So every line here is an
+ * item in source order, a file with no declaration still has a tree, and the
+ * checker is left holding the questions that are its to answer.
+ *
+ * Nothing in this file throws and nothing stops early. A statement that could
+ * not be read costs its own line and, where it opened one, its block; the next
+ * line is read as though nothing had happened, which is what lets a file with
+ * three mistakes in it produce three diagnostics from one compile.
+ */
+export declare function parse(file: SourceFile, diagnostics: DiagnosticSink): Script;
+/** The same, for a host that has already lexed the file and kept the tokens. */
+export declare function parseTokens(file: SourceFile, tokens: readonly Token[], diagnostics: DiagnosticSink): Script;
+//# sourceMappingURL=script.d.ts.map

package/dist/core/parse/script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"script.d.ts","sourceRoot":"","sources":["../../../src/core/parse/script.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAgB,MAAM,iBAAiB,CAAC;AAE5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAE9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAKhD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,cAAc,GAAG,MAAM,CAE3E;AAED,gFAAgF;AAChF,wBAAgB,WAAW,CACzB,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,WAAW,EAAE,cAAc,GAC1B,MAAM,CA6BR"}

package/dist/core/parse/script.js

@@ -0,0 +1,55 @@
+import { makeNode } from '../ast/index.js';
+import { lex } from '../lex/index.js';
+import { Cursor } from './cursor.js';
+import { parseFunctionDeclaration } from './functions.js';
+import { parseStatement } from './statements.js';
+/**
+ * A file, which is a list of statements and function declarations.
+ *
+ * Section 19 writes a file as a version line, a declaration and a limits line
+ * followed by the rest. The prose wins: the declaration being missing is
+ * OS2007, two of them is OS2008, and a version line that is not first is
+ * OS1021, all of which name a line and suggest a move. So every line here is an
+ * item in source order, a file with no declaration still has a tree, and the
+ * checker is left holding the questions that are its to answer.
+ *
+ * Nothing in this file throws and nothing stops early. A statement that could
+ * not be read costs its own line and, where it opened one, its block; the next
+ * line is read as though nothing had happened, which is what lets a file with
+ * three mistakes in it produce three diagnostics from one compile.
+ */
+export function parse(file, diagnostics) {
+    return parseTokens(file, lex(file, diagnostics), diagnostics);
+}
+/** The same, for a host that has already lexed the file and kept the tokens. */
+export function parseTokens(file, tokens, diagnostics) {
+    const cursor = new Cursor(file, tokens, diagnostics);
+    const items = [];
+    while (!cursor.at('endOfFile')) {
+        const before = cursor.position;
+        if (cursor.at('newline') || cursor.at('dedent') || cursor.at('indent')) {
+            // Layout with no statement to belong to, which a recovery can leave
+            // behind. Taking it here keeps the loop below reading statements only.
+            if (cursor.at('indent'))
+                cursor.skipBlockBody();
+            else
+                cursor.advance();
+            continue;
+        }
+        if (cursor.at('fn')) {
+            cursor.beginStatement();
+            const declaration = parseFunctionDeclaration(cursor);
+            cursor.noteStatement(declaration.span.line);
+            items.push(declaration);
+        }
+        else {
+            const statement = parseStatement(cursor);
+            if (statement !== undefined)
+                items.push(statement);
+        }
+        if (cursor.position === before)
+            cursor.skipStatement();
+    }
+    return makeNode('script', file.spanAt(0, file.text.length), { items });
+}
+//# sourceMappingURL=script.js.map

package/dist/core/parse/script.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"script.js","sourceRoot":"","sources":["../../../src/core/parse/script.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3C,OAAO,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAGtC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,KAAK,CAAC,IAAgB,EAAE,WAA2B;IACjE,OAAO,WAAW,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,CAAC;AAChE,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,WAAW,CACzB,IAAgB,EAChB,MAAwB,EACxB,WAA2B;IAE3B,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;IACrD,MAAM,KAAK,GAAmB,EAAE,CAAC;IAEjC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC;QAE/B,IAAI,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC;YACvE,oEAAoE;YACpE,uEAAuE;YACvE,IAAI,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC;gBAAE,MAAM,CAAC,aAAa,EAAE,CAAC;;gBAC3C,MAAM,CAAC,OAAO,EAAE,CAAC;YACtB,SAAS;QACX,CAAC;QAED,IAAI,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YACpB,MAAM,CAAC,cAAc,EAAE,CAAC;YACxB,MAAM,WAAW,GAAG,wBAAwB,CAAC,MAAM,CAAC,CAAC;YACrD,MAAM,CAAC,aAAa,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC5C,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC1B,CAAC;aAAM,CAAC;YACN,MAAM,SAAS,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;YACzC,IAAI,SAAS,KAAK,SAAS;gBAAE,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACrD,CAAC;QAED,IAAI,MAAM,CAAC,QAAQ,KAAK,MAAM;YAAE,MAAM,CAAC,aAAa,EAAE,CAAC;IACzD,CAAC;IAED,OAAO,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;AACzE,CAAC"}

package/dist/core/parse/statements.d.ts

@@ -0,0 +1,14 @@
+import type { FunctionDeclaration, Statement } from '../ast/index.js';
+import type { Cursor } from './cursor.js';
+export declare function parseStatement(cursor: Cursor): Statement | FunctionDeclaration | undefined;
+/**
+ * The end of a statement: a newline, and OS1018 for anything before it.
+ *
+ * A line holds at most one statement, so whatever is left over is either a
+ * missing operator or a second statement that lost its newline. It is only
+ * reported when the statement has nothing else wrong with it, because leftovers
+ * are what every other mistake on the line produces and the reader should be
+ * told about the mistake rather than about its wreckage.
+ */
+export declare function finishStatement(cursor: Cursor): void;
+//# sourceMappingURL=statements.d.ts.map

package/dist/core/parse/statements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statements.d.ts","sourceRoot":"","sources":["../../../src/core/parse/statements.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,mBAAmB,EACnB,SAAS,EAEV,MAAM,iBAAiB,CAAC;AAMzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAwB1C,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,GACb,SAAS,GAAG,mBAAmB,GAAG,SAAS,CAK7C;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAKpD"}

package/dist/core/parse/statements.js

@@ -0,0 +1,292 @@
+import { ASSIGNMENT_OPERATORS, makeNode, withoutGrouping } from '../ast/index.js';
+import { spanning } from '../span/index.js';
+import { parseTypeAnnotation } from './annotations.js';
+import { parseIfStatement } from './branches.js';
+import { missingExpression, parseArgumentList, parseExpression } from './expressions.js';
+import { parseFunctionDeclaration } from './functions.js';
+import { parseForStatement, parseWhileStatement } from './loops.js';
+import { isWordKind, takeName } from './names.js';
+import { parseSwitchStatement } from './switches.js';
+/**
+ * One statement, and the choice of which one it is.
+ *
+ * The choice is made from the first token and at most one more, which is what
+ * keeps the language readable: a line that begins with `if` is an `if` and
+ * nothing else, and the only lookahead anywhere is the token after a word,
+ * which says whether the word is being assigned to.
+ *
+ * Three of the forms here describe the file rather than compute anything. They
+ * are statements like the rest and may be written anywhere a statement may be,
+ * because the errors for putting one in the wrong place name a line and suggest
+ * a move (OS1021, OS2007, OS2008, OS3014), and a tree that refused to hold them
+ * could not carry a line number for any of those to report.
+ */
+const ASSIGNMENT = new Set(ASSIGNMENT_OPERATORS);
+export function parseStatement(cursor) {
+    cursor.beginStatement();
+    const statement = dispatch(cursor);
+    if (statement !== undefined)
+        cursor.noteStatement(statement.span.line);
+    return statement;
+}
+/**
+ * The end of a statement: a newline, and OS1018 for anything before it.
+ *
+ * A line holds at most one statement, so whatever is left over is either a
+ * missing operator or a second statement that lost its newline. It is only
+ * reported when the statement has nothing else wrong with it, because leftovers
+ * are what every other mistake on the line produces and the reader should be
+ * told about the mistake rather than about its wreckage.
+ */
+export function finishStatement(cursor) {
+    if (cursor.take('newline') !== undefined)
+        return;
+    if (cursor.atStatementEnd())
+        return;
+    if (!cursor.reportedHere)
+        cursor.unexpected(cursor.token);
+    cursor.skipToEndOfLine();
+}
+function dispatch(cursor) {
+    switch (cursor.kind) {
+        case 'if':
+            return parseIfStatement(cursor);
+        case 'for':
+            return parseForStatement(cursor);
+        case 'while':
+            return parseWhileStatement(cursor);
+        case 'switch':
+            return parseSwitchStatement(cursor);
+        case 'break':
+        case 'continue':
+            return parseJump(cursor);
+        case 'return':
+            return parseReturn(cursor);
+        case 'var':
+            return parseVarDeclaration(cursor, false);
+        case 'live':
+            return cursor.peek().kind === 'var'
+                ? parseVarDeclaration(cursor, true)
+                : parseSimpleStatement(cursor);
+        case 'study':
+        case 'strategy':
+            return parseScriptDeclaration(cursor);
+        case 'else':
+            return strayElse(cursor);
+        case 'case':
+        case 'default':
+            return strayArm(cursor);
+        case 'fn':
+            return nestedFunction(cursor);
+        default:
+            return parseSimpleStatement(cursor);
+    }
+}
+function parseSimpleStatement(cursor) {
+    const token = cursor.token;
+    // A block whose header was not understood, so nothing is left that could own
+    // it. Skipping it whole reports the header once instead of every line of it.
+    if (token.kind === 'indent') {
+        cursor.skipBlockBody();
+        return undefined;
+    }
+    if (token.kind === 'identifier') {
+        const next = cursor.peek();
+        // `version` and `limits` are not reserved words: a script written before
+        // either existed keeps compiling, so both are recognised by position.
+        if (token.text === 'version' && next.kind === 'numberLiteral') {
+            return parseVersionLine(cursor, next);
+        }
+        if (token.text === 'limits' && next.kind === '(')
+            return parseLimitsLine(cursor);
+    }
+    if (isWordKind(token.kind) && ASSIGNMENT.has(cursor.peek().kind)) {
+        return parseAssignment(cursor);
+    }
+    if (cursor.atStatementEnd()) {
+        cursor.take('newline');
+        return undefined;
+    }
+    const expression = parseExpression(cursor);
+    if (ASSIGNMENT.has(cursor.kind)) {
+        const refused = assignmentToSomethingOtherThanAName(cursor, expression);
+        if (refused !== undefined)
+            return refused;
+    }
+    finishStatement(cursor);
+    return makeNode('expressionStatement', expression.span, { expression });
+}
+/**
+ * An assignment whose target is an index or a member: OS1024 and OS1025.
+ *
+ * The grammar of section 19 has one assignment target and it is an identifier,
+ * so what is wrong on this line is the target and not the operator after it.
+ * That is why neither of these is OS1018, whose message would say the statement
+ * had ended before an operator the reader wrote in the middle of it. Two codes
+ * rather than one because the two have different fixes: an array element is
+ * written with a call, and a member is not written at all.
+ *
+ * Anything else the grammar cannot assign to, a literal or a call, is left to
+ * the caller and reported as OS1018, which is the nearest true thing the
+ * catalogue has for it.
+ *
+ * The value is read rather than skipped, so a mistake in it is reported on the
+ * same compile, and the statement reaches the tree as the target that was
+ * written. There is no node for an assignment whose target is not a name, and
+ * building one over a name taken out of the target, `prices` out of
+ * `prices[0]`, would put a different program in the tree from the one on the
+ * page.
+ */
+function assignmentToSomethingOtherThanAName(cursor, target) {
+    const written = withoutGrouping(target);
+    if (written.kind === 'index') {
+        cursor.report('OS1024', target.span, { name: cursor.textOf(written.target.span) });
+    }
+    else if (written.kind === 'member') {
+        cursor.report('OS1025', target.span, {
+            name: cursor.textOf(written.object.span),
+            member: written.member.text,
+        });
+    }
+    else {
+        return undefined;
+    }
+    // The operator, and then the value, which is read so that a mistake inside it
+    // is reported on this compile rather than on the one after the target is
+    // fixed.
+    cursor.advance();
+    const value = parseExpression(cursor);
+    finishStatement(cursor);
+    return makeNode('expressionStatement', spanning(target.span, value.span), {
+        expression: target,
+    });
+}
+function parseAssignment(cursor) {
+    const target = takeName(cursor);
+    const operator = cursor.advance().kind;
+    const value = parseExpression(cursor);
+    finishStatement(cursor);
+    return makeNode('assignment', spanning(target.span, value.span), { target, operator, value });
+}
+function parseVarDeclaration(cursor, live) {
+    const start = cursor.advance();
+    if (live)
+        cursor.advance();
+    const name = takeName(cursor);
+    const annotation = cursor.take(':') !== undefined ? parseTypeAnnotation(cursor) : undefined;
+    let initialiser;
+    if (cursor.take('=') !== undefined) {
+        initialiser = parseExpression(cursor);
+    }
+    else {
+        // The declaration and the first assignment are one statement, so a
+        // persistent value always has something in it and no bar can read it
+        // before it exists.
+        cursor.report('OS1011', spanning(start.span, name.span), { name: name.text });
+        initialiser = missingExpression(cursor);
+    }
+    finishStatement(cursor);
+    return makeNode('varDeclaration', spanning(start.span, initialiser.span), {
+        live,
+        name,
+        annotation,
+        initialiser,
+    });
+}
+function parseScriptDeclaration(cursor) {
+    const keyword = cursor.advance();
+    const open = cursor.take('(');
+    const list = open === undefined ? undefined : parseArgumentList(cursor, open);
+    finishStatement(cursor);
+    return makeNode('scriptDeclaration', spanning(keyword.span, list?.end ?? keyword.span), {
+        form: keyword.kind === 'study' ? 'study' : 'strategy',
+        args: list?.items ?? [],
+    });
+}
+function parseVersionLine(cursor, number) {
+    const word = cursor.advance();
+    cursor.advance();
+    const span = spanning(word.span, number.span);
+    const before = cursor.firstStatementLine;
+    if (before !== undefined)
+        cursor.report('OS1021', span, { line: before });
+    finishStatement(cursor);
+    return makeNode('versionLine', span, {
+        version: makeNode('numberLiteral', number.span, { value: number.value }),
+    });
+}
+function parseLimitsLine(cursor) {
+    const word = cursor.advance();
+    const list = parseArgumentList(cursor, cursor.advance());
+    finishStatement(cursor);
+    return makeNode('limitsLine', spanning(word.span, list.end), { args: list.items });
+}
+function parseJump(cursor) {
+    const keyword = cursor.advance();
+    if (!cursor.insideLoop)
+        cursor.report('OS1009', keyword.span, { word: keyword.text });
+    finishStatement(cursor);
+    return keyword.kind === 'break'
+        ? makeNode('breakStatement', keyword.span, {})
+        : makeNode('continueStatement', keyword.span, {});
+}
+function parseReturn(cursor) {
+    const keyword = cursor.advance();
+    // A bare `return` exits with `none`, so the value is genuinely absent here
+    // rather than a hole something went missing from.
+    const value = cursor.atStatementEnd() ? undefined : parseExpression(cursor);
+    finishStatement(cursor);
+    return makeNode('returnStatement', value === undefined ? keyword.span : spanning(keyword.span, value.span), { value });
+}
+/**
+ * An `else` that no `if` took.
+ *
+ * `parseIfStatement` takes the `else` that belongs to it, so one that reaches
+ * here has no `if` at its own indentation: either the statement above it is
+ * something else, or the lexer has already put the two in different blocks.
+ */
+function strayElse(cursor) {
+    const token = cursor.token;
+    cursor.report('OS1016', token.span, {
+        found: token.span.column - 1,
+        expected: cursor.nearestIfColumn - 1,
+    });
+    cursor.skipStatement();
+    return undefined;
+}
+function strayArm(cursor) {
+    const token = cursor.token;
+    cursor.report('OS1017', token.span, { word: token.text });
+    cursor.skipStatement();
+    return undefined;
+}
+/**
+ * A `fn` inside a block, which language.md 11.1 forbids: OS1023.
+ *
+ * It is read and it is kept. Reading it keeps the lines under it from being
+ * taken for statements of the block around it. Keeping it is what lets anything
+ * after the parser see the function at all: a declaration dropped here is gone
+ * from the tree, so a call to it could only ever be reported as a name nobody
+ * declared, and a nested function nobody calls would go unreported for good. It
+ * stays where the reader wrote it rather than being lifted to the top level,
+ * which would compile a file the language refuses.
+ *
+ * The caret covers `fn` and the name, which is the part of the declaration the
+ * reader has to move, and the same span OS1011 puts under `var name`.
+ *
+ * A header with no name at all has already been told that a name was expected,
+ * and the message here has nothing to name, so it waits: the node is kept
+ * either way, and the declaration is reported as nested once it has a name for
+ * the sentence to use and for the fix to tell the reader to call.
+ */
+function nestedFunction(cursor) {
+    const keyword = cursor.token;
+    const declaration = parseFunctionDeclaration(cursor);
+    if (declaration.name.text !== '') {
+        cursor.report('OS1023', spanning(keyword.span, declaration.name.span), {
+            name: declaration.name.text,
+        });
+    }
+    return declaration;
+}
+//# sourceMappingURL=statements.js.map

package/dist/core/parse/statements.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"statements.js","sourceRoot":"","sources":["../../../src/core/parse/statements.ts"],"names":[],"mappings":"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"}

package/dist/core/parse/switches.d.ts

@@ -0,0 +1,16 @@
+import type { SwitchStatement } from '../ast/index.js';
+import type { Cursor } from './cursor.js';
+/**
+ * `switch`, in both forms of language.md 10.6.
+ *
+ * With a subject each case value is compared against it, and without one each
+ * case value is a condition. The difference is the absent subject and needs no
+ * flag beside it.
+ *
+ * The arms are the whole of a switch body. A `default` that is not last would
+ * leave the arms after it unreachable, so the arm that follows one is OS1017,
+ * and the arm is kept in the tree all the same: a reader who moves the default
+ * should not then be told about the arms one at a time.
+ */
+export declare function parseSwitchStatement(cursor: Cursor): SwitchStatement;
+//# sourceMappingURL=switches.d.ts.map

package/dist/core/parse/switches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"switches.d.ts","sourceRoot":"","sources":["../../../src/core/parse/switches.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAyC,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAK9F,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAI1C;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CA0DpE"}