skir 0.0.1 → 0.0.2

package/src/parser.ts

@@ -1,6 +1,6 @@
-import * as casing from "./casing.js";
 import type {
   Declaration,
+  Doc,
   ErrorSink,
   FieldPath,
   Import,
@@ -16,7 +16,6 @@ import type {
   MutableRecordLevelDeclaration,
   MutableRecordLocation,
   MutableValue,
-  Numbering,
   Primitive,
   Record,
   Removed,
@@ -26,18 +25,19 @@ import type {
   UnresolvedArrayType,
   UnresolvedRecordRef,
   UnresolvedType,
-} from "./types.js";
+} from "skir-internal";
+import { convertCase, simpleHash } from "skir-internal";
+import * as casing from "./casing.js";
+import { parseDocComments } from "./doc_comment_parser.js";
+import { ModuleTokens } from "./tokenizer.js";
 
 /** Runs syntactic analysis on a module. */
-export function parseModule(
-  tokens: readonly Token[],
-  modulePath: string,
-  sourceCode: string,
-): Result<MutableModule> {
+export function parseModule(moduleTokens: ModuleTokens): Result<MutableModule> {
+  const { tokens, modulePath, sourceCode } = moduleTokens;
   const errors: SkirError[] = [];
   const it = new TokenIterator(tokens, errors);
   const declarations = parseDeclarations(it, "module");
-  it.expectThenMove([""]);
+  it.expectThenNext([""]);
   // Create a mappinng from names to declarations, and check for duplicates.
   const nameToDeclaration: { [name: string]: MutableModuleLevelDeclaration } =
     {};
@@ -53,7 +53,7 @@ export function parseModule(
       if (name in nameToDeclaration) {
         errors.push({
           token: nameToken,
-          message: `Duplicate identifier "${name}"`,
+          message: `Duplicate identifier '${name}'`,
         });
       } else {
         nameToDeclaration[name] = declaration;
@@ -103,11 +103,19 @@ function parseDeclarations(
     t === "" || (parentNode !== "module" && t === "}");
   // Returns true if the token may be the last token of a valid statement.
   const isLastToken = (t: string): boolean => t === "}" || t === ";";
-  while (!isEndToken(it.peek())) {
+  while (!isEndToken(it.current)) {
     const startIndex = it.index;
     const declaration = parseDeclaration(it, parentNode);
     if (declaration !== null) {
       result.push(declaration);
+      if (declaration.kind === "method") {
+        if (declaration.inlineRequestRecord) {
+          result.push(declaration.inlineRequestRecord);
+        }
+        if (declaration.inlineResponseRecord) {
+          result.push(declaration.inlineResponseRecord);
+        }
+      }
       continue;
     }
     // We have an invalid statement. An error was already registered. Perhaps
@@ -118,18 +126,18 @@ function parseDeclarations(
     const noTokenWasConsumed = it.index === startIndex;
     if (noTokenWasConsumed) {
       it.next();
-      if (isLastToken(it.peekBack())) {
+      if (isLastToken(it.previous)) {
         // For example: two semicolons in a row.
         continue;
       }
     }
     if (
       noTokenWasConsumed ||
-      (it.peek() !== "" && !isLastToken(it.peekBack()))
+      (it.current !== "" && !isLastToken(it.previous))
     ) {
       let nestedLevel = 0;
       while (true) {
-        const token = it.peek();
+        const token = it.current;
         if (token === "") {
           break;
         }
@@ -152,6 +160,7 @@ function parseDeclaration(
   it: TokenIterator,
   parentNode: "module" | "struct" | "enum",
 ): MutableDeclaration | null {
+  const doc = parseDoc(it);
   let recordType: "struct" | "enum" = "enum";
   const parentIsRoot = parentNode === "module";
   const expected = [
@@ -163,23 +172,23 @@ function parseDeclaration(
     /*5:*/ parentIsRoot ? "method" : null,
     /*6:*/ parentIsRoot ? "const" : null,
   ];
-  const match = it.expectThenMove(expected);
+  const match = it.expectThenNext(expected);
   switch (match.case) {
     case 0:
       recordType = "struct";
     // Falls through.
     case 1:
-      return parseRecord(it, recordType);
+      return parseRecord(it, recordType, doc);
     case 2:
       return parseRemoved(it, match.token);
     case 3:
-      return parseField(it, match.token, parentNode as "struct" | "enum");
+      return parseField(it, match.token, doc, parentNode as "struct" | "enum");
     case 4:
       return parseImport(it);
     case 5:
-      return parseMethod(it);
+      return parseMethod(it, doc);
     case 6:
-      return parseConstant(it);
+      return parseConstant(it, doc);
     default:
       return null;
   }
@@ -189,6 +198,7 @@ class RecordBuilder {
   constructor(
     private readonly recordName: Token,
     private readonly recordType: "struct" | "enum",
+    private readonly doc: Doc,
     private readonly stableId: number | null,
     private readonly errors: ErrorSink,
   ) {}
@@ -253,7 +263,7 @@ class RecordBuilder {
       if (name in this.nameToDeclaration) {
         this.errors.push({
           token: nameToken,
-          message: `Duplicate identifier "${name}"`,
+          message: `Duplicate identifier '${name}'`,
         });
         return;
       }
@@ -326,11 +336,11 @@ class RecordBuilder {
       key: key,
       name: this.recordName,
       recordType: this.recordType,
+      doc: this.doc,
       nameToDeclaration: this.nameToDeclaration,
       declarations: Object.values(this.nameToDeclaration),
       fields: fields,
       nestedRecords: nestedRecords,
-      numbering: this.numbering,
       removedNumbers: this.removedNumbers.sort(),
       recordNumber: this.stableId,
       numSlots: numSlots,
@@ -345,40 +355,79 @@ class RecordBuilder {
   private removedNumbers: number[] = [];
 }
 
+type Numbering =
+  // The record does not have fields .
+  | ""
+  // Field numbers are not explicit in the schema.
+  | "implicit"
+  // Field numbers are explicit in the schema.
+  | "explicit"
+  // The record has both fields with implicit and explicit numbering.
+  | "broken";
+
+interface InlineRecordContext {
+  context: "field" | "method-request" | "method-response";
+  /** Name of the field or method. */
+  originalName: Token;
+}
+
 function parseRecord(
   it: TokenIterator,
   recordType: "struct" | "enum",
+  doc: Doc,
+  inlineContext?: InlineRecordContext,
 ): MutableRecord | null {
   // A struct or an enum.
-  const nameMatch = it.expectThenMove([TOKEN_IS_IDENTIFIER]);
-  if (nameMatch.case < 0) {
-    return null;
+  let nameToken: Token;
+  if (inlineContext) {
+    const { originalName } = inlineContext;
+    let transformedName = convertCase(originalName.text, "UpperCamel");
+    if (inlineContext.context === "method-request") {
+      transformedName += "Request";
+    } else if (inlineContext.context === "method-response") {
+      transformedName += "Response";
+    }
+    nameToken = {
+      ...originalName,
+      text: transformedName,
+    };
+  } else {
+    // Read the name.
+    const nameMatch = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
+    if (nameMatch.case < 0) {
+      return null;
+    }
+    casing.validate(nameMatch.token, "UpperCamel", it.errors);
+    nameToken = nameMatch.token;
   }
-  casing.validate(nameMatch.token, "UpperCamel", it.errors);
   let stableId: number | null = null;
-  if (it.peek() === "(") {
+  if (it.current === "(") {
     it.next();
     stableId = parseUint32(it);
     if (stableId < 0) {
       return null;
     }
-    if (it.expectThenMove([")"]).case < 0) {
+    if (it.expectThenNext([")"]).case < 0) {
       return null;
     }
   }
-  if (it.expectThenMove(["{"]).case < 0) {
+  if (it.expectThenNext(["{"]).case < 0) {
     return null;
   }
   const declarations = parseDeclarations(it, recordType);
-  it.expectThenMove(["}"]);
+  it.expectThenNext(["}"]);
   const builder = new RecordBuilder(
-    nameMatch.token,
+    nameToken,
     recordType,
+    doc,
     stableId,
     it.errors,
   );
   for (const declaration of declarations) {
     builder.addDeclaration(declaration);
+    if (declaration.kind === "field" && declaration.inlineRecord) {
+      builder.addDeclaration(declaration.inlineRecord);
+    }
   }
   return builder.build();
 }
@@ -386,12 +435,13 @@ function parseRecord(
 function parseField(
   it: TokenIterator,
   name: Token,
+  doc: Doc,
   recordType: "struct" | "enum",
 ): MutableField | null {
   // May only be undefined if the type is an enum.
-  let type: UnresolvedType | undefined = undefined;
+  let type: UnresolvedType | undefined;
+  let inlineRecord: MutableRecord | undefined;
   let number = -1;
-
   while (true) {
     const typeAllowed = type === undefined && number < 0;
     const endAllowed = type !== undefined || recordType === "enum";
@@ -401,10 +451,16 @@ function parseField(
       /*1:*/ numberAllowed ? "=" : null,
       /*2:*/ endAllowed ? ";" : null,
     ];
-    const match = it.expectThenMove(expected);
+    const match = it.expectThenNext(expected);
     switch (match.case) {
       case 0: {
-        type = parseType(it);
+        const inlineContext: InlineRecordContext = {
+          context: "field",
+          originalName: name,
+        };
+        const typeOrInlineRecord = parseTypeOrInlineRecord(it, inlineContext);
+        type = typeOrInlineRecord.type;
+        inlineRecord = typeOrInlineRecord.inlineRecord;
         if (type === undefined) {
           return null;
         }
@@ -431,11 +487,13 @@ function parseField(
           kind: "field",
           name: name,
           number: number,
+          doc: doc,
           unresolvedType: type,
           // Will be populated at a later stage.
           type: undefined,
           // Will be populated at a later stage.
           isRecursive: false,
+          inlineRecord: inlineRecord,
         };
       }
       case -1:
@@ -456,8 +514,38 @@ const PRIMITIVE_TYPES: ReadonlySet<string> = new Set<Primitive>([
   "bytes",
 ]);
 
+function parseTypeOrInlineRecord(
+  it: TokenIterator,
+  inlineContext: InlineRecordContext,
+): {
+  type: UnresolvedType | undefined;
+  inlineRecord: MutableRecord | undefined;
+} {
+  if (it.current === "struct" || it.current === "enum") {
+    const recordType = it.current as "struct" | "enum";
+    it.next();
+    const inlineRecord = parseRecord(it, recordType, EMPTY_DOC, inlineContext);
+    const type: UnresolvedRecordRef | undefined = inlineRecord
+      ? {
+          kind: "record",
+          nameParts: [inlineRecord.name],
+          absolute: false,
+        }
+      : undefined;
+    return {
+      type: type,
+      inlineRecord: inlineRecord ? inlineRecord : undefined,
+    };
+  } else {
+    return {
+      type: parseType(it),
+      inlineRecord: undefined,
+    };
+  }
+}
+
 function parseType(it: TokenIterator): UnresolvedType | undefined {
-  const match = it.expectThenMove([
+  const match = it.expectThenNext([
     /*0:*/ "[",
     /*1:*/ TOKEN_IS_IDENTIFIER,
     /*2:*/ ".",
@@ -490,7 +578,7 @@ function parseType(it: TokenIterator): UnresolvedType | undefined {
   if (value === undefined) {
     return undefined;
   }
-  if (it.peek() === "?") {
+  if (it.current === "?") {
     it.next();
     return { kind: "optional", other: value };
   } else {
@@ -506,7 +594,7 @@ function parseArrayType(it: TokenIterator): UnresolvedArrayType | undefined {
   let key: FieldPath | undefined = undefined;
   while (true) {
     const keyAllowed = !key && item.kind === "record";
-    const match = it.expectThenMove([
+    const match = it.expectThenNext([
       /*0:*/ keyAllowed ? "|" : null,
       /*1:*/ "]",
     ]);
@@ -533,12 +621,12 @@ function parseFieldPath(
 ): FieldPath | undefined {
   const fieldNames: Token[] = [];
   while (true) {
-    const match = it.expectThenMove([TOKEN_IS_IDENTIFIER]);
+    const match = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
     if (match.case < 0) {
       return undefined;
     }
     fieldNames.push(match.token);
-    if (it.peek() === ".") {
+    if (it.current === ".") {
       it.next();
     } else {
       break;
@@ -563,7 +651,7 @@ function parseRecordRef(
   const absolute = nameOrDot.text === ".";
   const nameParts: Token[] = [];
   if (nameOrDot.text === ".") {
-    const match = it.expectThenMove([TOKEN_IS_IDENTIFIER]);
+    const match = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
     if (match.case < 0) {
       return undefined;
     }
@@ -571,9 +659,9 @@ function parseRecordRef(
   } else {
     nameParts.push(nameOrDot);
   }
-  while (it.peek() === ".") {
+  while (it.current === ".") {
     it.next();
-    const match = it.expectThenMove([TOKEN_IS_IDENTIFIER]);
+    const match = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
     if (match.case < 0) {
       return undefined;
     }
@@ -583,7 +671,7 @@ function parseRecordRef(
 }
 
 function parseUint32(it: TokenIterator): number {
-  const match = it.expectThenMove([TOKEN_IS_POSITIVE_INT]);
+  const match = it.expectThenNext([TOKEN_IS_POSITIVE_INT]);
   if (match.case < 0) {
     return -1;
   }
@@ -600,8 +688,8 @@ function parseUint32(it: TokenIterator): number {
   }
 }
 
-// Parses the "removed" declaration.
-// Assumes the current token is the token after "removed".
+// Parses the 'removed' declaration.
+// Assumes the current token is the token after 'removed'.
 function parseRemoved(it: TokenIterator, removedToken: Token): Removed | null {
   const numbers: number[] = [];
   // The 5 states are:
@@ -621,7 +709,7 @@ function parseRemoved(it: TokenIterator, removedToken: Token): Removed | null {
       /*2:*/ expect === "?" || expect === "," || expect === ".." ? ";" : null,
       /*3:*/ expect === ".." ? ".." : null,
     ];
-    const match = it.expectThenMove(expected);
+    const match = it.expectThenNext(expected);
     switch (match.case) {
       case 0: {
         // A comma.
@@ -684,7 +772,7 @@ function parseRemoved(it: TokenIterator, removedToken: Token): Removed | null {
 }
 
 function parseImport(it: TokenIterator): Import | ImportAlias | null {
-  const tokenMatch = it.expectThenMove(["*", TOKEN_IS_IDENTIFIER]);
+  const tokenMatch = it.expectThenNext(["*", TOKEN_IS_IDENTIFIER]);
   switch (tokenMatch.case) {
     case 0:
       return parseImportAs(it);
@@ -696,18 +784,18 @@ function parseImport(it: TokenIterator): Import | ImportAlias | null {
 }
 
 function parseImportAs(it: TokenIterator): ImportAlias | null {
-  if (it.expectThenMove(["as"]).case < 0) return null;
-  const aliasMatch = it.expectThenMove([TOKEN_IS_IDENTIFIER]);
+  if (it.expectThenNext(["as"]).case < 0) return null;
+  const aliasMatch = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
   if (aliasMatch.case < 0) {
     return null;
   }
   casing.validate(aliasMatch.token, "lower_underscore", it.errors);
-  if (it.expectThenMove(["from"]).case < 0) return null;
-  const modulePathMatch = it.expectThenMove([TOKEN_IS_STRING_LITERAL]);
+  if (it.expectThenNext(["from"]).case < 0) return null;
+  const modulePathMatch = it.expectThenNext([TOKEN_IS_STRING_LITERAL]);
   if (modulePathMatch.case < 0) {
     return null;
   }
-  it.expectThenMove([";"]);
+  it.expectThenNext([";"]);
   const modulePath = modulePathMatch.token;
   return {
     kind: "import-alias",
@@ -721,20 +809,20 @@ function parseImportGivenNames(
   it: TokenIterator,
 ): Import | null {
   const importedNames = [firstName];
-  while (it.peek() === ",") {
+  while (it.current === ",") {
     it.next();
-    const nameMatch = it.expectThenMove([TOKEN_IS_IDENTIFIER]);
+    const nameMatch = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
     if (nameMatch.case < 0) {
       return null;
     }
     importedNames.push(nameMatch.token);
   }
-  if (it.expectThenMove(["from"]).case < 0) return null;
-  const modulePathMatch = it.expectThenMove([TOKEN_IS_STRING_LITERAL]);
+  if (it.expectThenNext(["from"]).case < 0) return null;
+  const modulePathMatch = it.expectThenNext([TOKEN_IS_STRING_LITERAL]);
   if (modulePathMatch.case < 0) {
     return null;
   }
-  it.expectThenMove([";"]);
+  it.expectThenNext([";"]);
   const modulePath = modulePathMatch.token;
   return {
     kind: "import",
@@ -743,35 +831,44 @@ function parseImportGivenNames(
   };
 }
 
-function parseMethod(it: TokenIterator): MutableMethod | null {
-  const nameMatch = it.expectThenMove([TOKEN_IS_IDENTIFIER]);
+function parseMethod(it: TokenIterator, doc: Doc): MutableMethod | null {
+  const nameMatch = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
   if (nameMatch.case < 0) {
     return null;
   }
-  casing.validate(nameMatch.token, "UpperCamel", it.errors);
-  if (it.expectThenMove(["("]).case < 0) {
+  const name = nameMatch.token;
+  casing.validate(name, "UpperCamel", it.errors);
+  if (it.expectThenNext(["("]).case < 0) {
     return null;
   }
-  const requestType = parseType(it);
+  const requestTypeOrInlineRecord = parseTypeOrInlineRecord(it, {
+    context: "method-request",
+    originalName: name,
+  });
+  const requestType = requestTypeOrInlineRecord.type;
   if (!requestType) {
     return null;
   }
-  if (it.expectThenMove([")"]).case < 0 || it.expectThenMove([":"]).case < 0) {
+  if (it.expectThenNext([")"]).case < 0 || it.expectThenNext([":"]).case < 0) {
     return null;
   }
-  const responseType = parseType(it);
+  const responseTypeOrInlineRecord = parseTypeOrInlineRecord(it, {
+    context: "method-response",
+    originalName: name,
+  });
+  const responseType = responseTypeOrInlineRecord.type;
   if (!responseType) {
     return null;
   }
 
-  const explicitNumber = it.expectThenMove(["=", ";"]).case === 0;
+  const explicitNumber = it.expectThenNext(["=", ";"]).case === 0;
   let number: number;
   if (explicitNumber) {
     number = parseUint32(it);
     if (number < 0) {
       return null;
     }
-    it.expectThenMove([";"]);
+    it.expectThenNext([";"]);
   } else {
     const methodName = nameMatch.token.text;
     const { modulePath } = nameMatch.token.line;
@@ -781,6 +878,7 @@ function parseMethod(it: TokenIterator): MutableMethod | null {
   return {
     kind: "method",
     name: nameMatch.token,
+    doc: doc,
     unresolvedRequestType: requestType,
     unresolvedResponseType: responseType,
     // Will be populated at a later stage.
@@ -789,33 +887,36 @@ function parseMethod(it: TokenIterator): MutableMethod | null {
     responseType: undefined,
     number: number,
     hasExplicitNumber: explicitNumber,
+    inlineRequestRecord: requestTypeOrInlineRecord.inlineRecord,
+    inlineResponseRecord: responseTypeOrInlineRecord.inlineRecord,
   };
 }
 
-function parseConstant(it: TokenIterator): MutableConstant | null {
-  const nameMatch = it.expectThenMove([TOKEN_IS_IDENTIFIER]);
+function parseConstant(it: TokenIterator, doc: Doc): MutableConstant | null {
+  const nameMatch = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
   if (nameMatch.case < 0) {
     return null;
   }
   casing.validate(nameMatch.token, "UPPER_UNDERSCORE", it.errors);
-  if (it.expectThenMove([":"]).case < 0) {
+  if (it.expectThenNext([":"]).case < 0) {
     return null;
   }
   const type = parseType(it);
   if (!type) {
     return null;
   }
-  if (it.expectThenMove(["="]).case < 0) {
+  if (it.expectThenNext(["="]).case < 0) {
     return null;
   }
   const value = parseValue(it);
   if (value === null) {
     return null;
   }
-  it.expectThenMove([";"]);
+  it.expectThenNext([";"]);
   return {
     kind: "constant",
     name: nameMatch.token,
+    doc: doc,
     unresolvedType: type,
     type: undefined,
     value: value,
@@ -834,7 +935,7 @@ function parseValue(it: TokenIterator): MutableValue | null {
     /*6:*/ TOKEN_IS_NUMBER,
     /*7:*/ TOKEN_IS_STRING_LITERAL,
   ];
-  const match = it.expectThenMove(expected);
+  const match = it.expectThenNext(expected);
   switch (match.case) {
     case 0:
     case 1: {
@@ -882,17 +983,17 @@ function parseObjectValue(
   const closingToken = partial ? "|}" : "}";
   const entries: { [f: string]: MutableObjectEntry } = {};
   while (true) {
-    if (it.peek() === closingToken) {
+    if (it.current === closingToken) {
       it.next();
       return entries;
     }
-    const fieldNameMatch = it.expectThenMove([TOKEN_IS_IDENTIFIER]);
+    const fieldNameMatch = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
     if (fieldNameMatch.case < 0) {
       return null;
     }
     const fieldNameToken = fieldNameMatch.token;
     const fieldName = fieldNameMatch.token.text;
-    if (it.expectThenMove([":"]).case < 0) {
+    if (it.expectThenNext([":"]).case < 0) {
       return null;
     }
     const value = parseValue(it);
@@ -909,7 +1010,7 @@ function parseObjectValue(
       name: fieldNameToken,
       value: value,
     };
-    const endMatch = it.expectThenMove([",", closingToken]);
+    const endMatch = it.expectThenNext([",", closingToken]);
     if (endMatch.case < 0) {
       return null;
     }
@@ -920,7 +1021,7 @@ function parseObjectValue(
 }
 
 function parseArrayValue(it: TokenIterator): MutableValue[] | null {
-  if (it.peek() === "]") {
+  if (it.current === "]") {
     it.next();
     return [];
   }
@@ -931,20 +1032,35 @@ function parseArrayValue(it: TokenIterator): MutableValue[] | null {
       return null;
     }
     items.push(item);
-    const match = it.expectThenMove([",", "]"]);
+    const match = it.expectThenNext([",", "]"]);
     if (match.case < 0) {
       return null;
     }
     if (match.token.text === "]") {
       return items;
     }
-    if (it.peek() === "]") {
+    if (it.current === "]") {
       it.next();
       return items;
     }
   }
 }
 
+function parseDoc(it: TokenIterator): Doc {
+  const docComments: Token[] = [];
+  while (it.current.startsWith("///")) {
+    docComments.push(it.currentToken);
+    it.next();
+  }
+  const result = parseDocComments(docComments);
+  result.errors.forEach((e) => it.errors.push(e));
+  return result.result;
+}
+
+const EMPTY_DOC: Doc = {
+  pieces: [],
+};
+
 abstract class TokenPredicate {
   abstract matches(token: string): boolean;
   abstract what(): string;
@@ -1016,10 +1132,18 @@ class TokenIterator {
   //
   // If the current token matches any predicate, i.e. if the index is not -1,
   // moves to the next token before returning. Otherwise, registers an error.
-  expectThenMove(
+  expectThenNext(
     expected: ReadonlyArray<string | TokenPredicate | null>,
   ): TokenMatch {
-    const token = this.tokens[this.tokenIndex]!;
+    let token = this.tokens[this.tokenIndex]!;
+    while (token.text.startsWith("///")) {
+      this.errors.push({
+        token: token,
+        message: "Doc comments can only precede declarations",
+      });
+      ++this.tokenIndex;
+      token = this.tokens[this.tokenIndex]!;
+    }
     for (let i = 0; i < expected.length; ++i) {
       const e = expected[i];
       if (e === null) {
@@ -1044,7 +1168,7 @@ class TokenIterator {
       if (e === null) {
         continue;
       }
-      expectedParts.push(e instanceof TokenPredicate ? e.what() : `"${e}"`);
+      expectedParts.push(e instanceof TokenPredicate ? e.what() : `'${e}'`);
     }
     const expectedMsg =
       expectedParts.length === 1
@@ -1062,11 +1186,15 @@ class TokenIterator {
     };
   }
 
-  peek(): string {
-    return this.tokens[this.tokenIndex]!.text;
+  get currentToken(): Token {
+    return this.tokens[this.tokenIndex]!;
   }
 
-  peekBack(): string {
+  get current(): string {
+    return this.currentToken.text;
+  }
+
+  get previous(): string {
     return this.tokens[this.tokenIndex - 1]!.text;
   }
 
@@ -1081,19 +1209,6 @@ class TokenIterator {
   private tokenIndex = 0;
 }
 
-/** Returns a uint32 hash of the given string. */
-export function simpleHash(input: string): number {
-  // From https://stackoverflow.com/questions/6122571/simple-non-secure-hash-function-for-javascript
-  let hash = 0;
-  for (let i = 0; i < input.length; i++) {
-    const char = input.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash |= 0;
-  }
-  // Signed int32 to unsigned int32.
-  return hash >>> 0;
-}
-
 function collectModuleRecords(
   declarations: readonly Declaration[],
 ): MutableRecordLocation[] {