文法エラーに位置情報を追加 (#413)

marihachi · web-flow · commit 86eb9deeabf6 · 2023-10-20T10:42:05.000+09:00
* error location for parser

* type error location

* fix error message
diff --git a/etc/aiscript.api.md b/etc/aiscript.api.md
@@ -36,14 +36,18 @@ class AiScriptRuntimeError extends AiScriptError {
 
 // @public
 class AiScriptSyntaxError extends AiScriptError {
-    constructor(message: string, info?: any);
+    constructor(message: string, loc: Loc, info?: any);
+    // (undocumented)
+    loc: Loc;
     // (undocumented)
     name: string;
 }
 
 // @public
 class AiScriptTypeError extends AiScriptError {
-    constructor(message: string, info?: any);
+    constructor(message: string, loc: Loc, info?: any);
+    // (undocumented)
+    loc: Loc;
     // (undocumented)
     name: string;
 }
diff --git a/src/error.ts b/src/error.ts
@@ -1,3 +1,5 @@
+import type { Loc } from './node.js';
+
 export abstract class AiScriptError extends Error {
 	// name is read by Error.prototype.toString
 	public name = 'AiScript';
@@ -30,17 +32,17 @@ export class NonAiScriptError extends AiScriptError {
  */
 export class AiScriptSyntaxError extends AiScriptError {
 	public name = 'Syntax';
-	constructor(message: string, info?: any) {
-		super(message, info);
+	constructor(message: string, public loc: Loc, info?: any) {
+		super(`${message} (Line ${loc.line}, Column ${loc.column})`, info);
 	}
 }
 /**
  * Type validation(parser/plugins/validate-type) errors.
  */ 
 export class AiScriptTypeError extends AiScriptError {
 	public name = 'Type';
-	constructor(message: string, info?: any) {
-		super(message, info);
+	constructor(message: string, public loc: Loc, info?: any) {
+		super(`${message} (Line ${loc.line}, Column ${loc.column})`, info);
 	}
 }
 
diff --git a/src/parser/plugins/validate-keyword.ts b/src/parser/plugins/validate-keyword.ts
@@ -42,8 +42,8 @@ const reservedWord = [
 	// 'out',
 ];
 
-function throwReservedWordError(name: string): void {
-	throw new AiScriptSyntaxError(`Reserved word "${name}" cannot be used as variable name.`);
+function throwReservedWordError(name: string, loc: Ast.Loc): void {
+	throw new AiScriptSyntaxError(`Reserved word "${name}" cannot be used as variable name.`, loc);
 }
 
 function validateNode(node: Ast.Node): Ast.Node {
@@ -53,20 +53,20 @@ function validateNode(node: Ast.Node): Ast.Node {
 		case 'ns':
 		case 'identifier': {
 			if (reservedWord.includes(node.name)) {
-				throwReservedWordError(node.name);
+				throwReservedWordError(node.name, node.loc);
 			}
 			break;
 		}
 		case 'meta': {
 			if (node.name != null && reservedWord.includes(node.name)) {
-				throwReservedWordError(node.name);
+				throwReservedWordError(node.name, node.loc);
 			}
 			break;
 		}
 		case 'fn': {
 			for (const arg of node.args) {
 				if (reservedWord.includes(arg.name)) {
-					throwReservedWordError(arg.name);
+					throwReservedWordError(arg.name, node.loc);
 				}
 			}
 			break;
diff --git a/src/parser/scanner.ts b/src/parser/scanner.ts
@@ -75,7 +75,7 @@ export class Scanner implements ITokenStream {
 	*/
 	public expect(kind: TokenKind): void {
 		if (this.kind !== kind) {
-			throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[this.kind]}`);
+			throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[this.kind]}`, this.token.loc);
 		}
 	}
 
@@ -140,7 +140,7 @@ export class Scanner implements ITokenStream {
 						this.stream.next();
 						token = TOKEN(TokenKind.OpenSharpBracket, loc, { hasLeftSpacing });
 					} else {
-						throw new AiScriptSyntaxError('invalid character: "#"');
+						throw new AiScriptSyntaxError('invalid character: "#"', loc);
 					}
 					break;
 				}
@@ -327,7 +327,7 @@ export class Scanner implements ITokenStream {
 					token = wordToken;
 					break;
 				}
-				throw new AiScriptSyntaxError(`invalid character: "${this.stream.char}"`);
+				throw new AiScriptSyntaxError(`invalid character: "${this.stream.char}"`, loc);
 			}
 			break;
 		}
@@ -432,7 +432,7 @@ export class Scanner implements ITokenStream {
 				this.stream.next();
 			}
 			if (fractional.length === 0) {
-				throw new AiScriptSyntaxError('digit expected');
+				throw new AiScriptSyntaxError('digit expected', loc);
 			}
 		}
 		let value;
@@ -456,7 +456,7 @@ export class Scanner implements ITokenStream {
 			switch (state) {
 				case 'string': {
 					if (this.stream.eof) {
-						throw new AiScriptSyntaxError('unexpected EOF');
+						throw new AiScriptSyntaxError('unexpected EOF', loc);
 					}
 					if (this.stream.char === '\\') {
 						this.stream.next();
@@ -474,7 +474,7 @@ export class Scanner implements ITokenStream {
 				}
 				case 'escape': {
 					if (this.stream.eof) {
-						throw new AiScriptSyntaxError('unexpected EOF');
+						throw new AiScriptSyntaxError('unexpected EOF', loc);
 					}
 					value += this.stream.char;
 					this.stream.next();
@@ -501,7 +501,7 @@ export class Scanner implements ITokenStream {
 				case 'string': {
 					// テンプレートの終了が無いままEOFに達した
 					if (this.stream.eof) {
-						throw new AiScriptSyntaxError('unexpected EOF');
+						throw new AiScriptSyntaxError('unexpected EOF', loc);
 					}
 					// エスケープ
 					if (this.stream.char === '\\') {
@@ -537,7 +537,7 @@ export class Scanner implements ITokenStream {
 				case 'escape': {
 					// エスケープ対象の文字が無いままEOFに達した
 					if (this.stream.eof) {
-						throw new AiScriptSyntaxError('unexpected EOF');
+						throw new AiScriptSyntaxError('unexpected EOF', loc);
 					}
 					// 普通の文字として取り込み
 					buf += this.stream.char;
@@ -549,7 +549,7 @@ export class Scanner implements ITokenStream {
 				case 'expr': {
 					// 埋め込み式の終端記号が無いままEOFに達した
 					if (this.stream.eof) {
-						throw new AiScriptSyntaxError('unexpected EOF');
+						throw new AiScriptSyntaxError('unexpected EOF', loc);
 					}
 					// skip spasing
 					if (spaceChars.includes(this.stream.char)) {
diff --git a/src/parser/streams/token-stream.ts b/src/parser/streams/token-stream.ts
@@ -101,7 +101,7 @@ export class TokenStream implements ITokenStream {
 	*/
 	public expect(kind: TokenKind): void {
 		if (this.kind !== kind) {
-			throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[this.kind]}`);
+			throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[this.kind]}`, this.token.loc);
 		}
 	}
 
diff --git a/src/parser/syntaxes/common.ts b/src/parser/syntaxes/common.ts
@@ -22,7 +22,7 @@ export function parseParams(s: ITokenStream): { name: string, argType?: Ast.Node
 			if (s.kind === TokenKind.Comma) {
 				s.next();
 			} else if (!s.token.hasLeftSpacing) {
-				throw new AiScriptSyntaxError('separator expected');
+				throw new AiScriptSyntaxError('separator expected', s.token.loc);
 			}
 		}
 
@@ -61,7 +61,7 @@ export function parseBlock(s: ITokenStream): Ast.Node[] {
 		steps.push(parseStatement(s));
 
 		if ((s.kind as TokenKind) !== TokenKind.NewLine && (s.kind as TokenKind) !== TokenKind.CloseBrace) {
-			throw new AiScriptSyntaxError('Multiple statements cannot be placed on a single line.');
+			throw new AiScriptSyntaxError('Multiple statements cannot be placed on a single line.', s.token.loc);
 		}
 		while ((s.kind as TokenKind) === TokenKind.NewLine) {
 			s.next();
@@ -101,7 +101,7 @@ function parseFnType(s: ITokenStream): Ast.Node {
 			if (s.kind === TokenKind.Comma) {
 				s.next();
 			} else if (!s.token.hasLeftSpacing) {
-				throw new AiScriptSyntaxError('separator expected');
+				throw new AiScriptSyntaxError('separator expected', s.token.loc);
 			}
 		}
 		const type = parseType(s);
diff --git a/src/parser/syntaxes/expressions.ts b/src/parser/syntaxes/expressions.ts
@@ -70,7 +70,7 @@ function parsePrefix(s: ITokenStream, minBp: number): Ast.Node {
 			if (expr.type === 'num') {
 				return NODE('num', { value: expr.value }, loc);
 			} else {
-				throw new AiScriptSyntaxError('currently, sign is only supported for number literal.');
+				throw new AiScriptSyntaxError('currently, sign is only supported for number literal.', loc);
 			}
 			// TODO: 将来的にサポートされる式を拡張
 			// return NODE('plus', { expr }, loc);
@@ -80,7 +80,7 @@ function parsePrefix(s: ITokenStream, minBp: number): Ast.Node {
 			if (expr.type === 'num') {
 				return NODE('num', { value: -1 * expr.value }, loc);
 			} else {
-				throw new AiScriptSyntaxError('currently, sign is only supported for number literal.');
+				throw new AiScriptSyntaxError('currently, sign is only supported for number literal.', loc);
 			}
 			// TODO: 将来的にサポートされる式を拡張
 			// return NODE('minus', { expr }, loc);
@@ -89,7 +89,7 @@ function parsePrefix(s: ITokenStream, minBp: number): Ast.Node {
 			return NODE('not', { expr }, loc);
 		}
 		default: {
-			throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[op]}`);
+			throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[op]}`, loc);
 		}
 	}
 }
@@ -161,7 +161,7 @@ function parseInfix(s: ITokenStream, left: Ast.Node, minBp: number): Ast.Node {
 				return NODE('or', { left, right }, loc);
 			}
 			default: {
-				throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[op]}`);
+				throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[op]}`, loc);
 			}
 		}
 	}
@@ -186,7 +186,7 @@ function parsePostfix(s: ITokenStream, expr: Ast.Node): Ast.Node {
 			}, loc);
 		}
 		default: {
-			throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[op]}`);
+			throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[op]}`, loc);
 		}
 	}
 }
@@ -231,13 +231,13 @@ function parseAtom(s: ITokenStream, isStatic: boolean): Ast.Node {
 						const exprStream = new TokenStream(element.children!);
 						const expr = parseExpr(exprStream, false);
 						if (exprStream.kind !== TokenKind.EOF) {
-							throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[exprStream.token.kind]}`);
+							throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[exprStream.token.kind]}`, exprStream.token.loc);
 						}
 						values.push(expr);
 						break;
 					}
 					default: {
-						throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[element.kind]}`);
+						throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[element.kind]}`, element.loc);
 					}
 				}
 			}
@@ -283,7 +283,7 @@ function parseAtom(s: ITokenStream, isStatic: boolean): Ast.Node {
 			return expr;
 		}
 	}
-	throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[s.kind]}`);
+	throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[s.kind]}`, loc);
 }
 
 /**
@@ -301,7 +301,7 @@ function parseCall(s: ITokenStream, target: Ast.Node): Ast.Node {
 			if (s.kind === TokenKind.Comma) {
 				s.next();
 			} else if (!s.token.hasLeftSpacing) {
-				throw new AiScriptSyntaxError('separator expected');
+				throw new AiScriptSyntaxError('separator expected', s.token.loc);
 			}
 		}
 
@@ -451,11 +451,11 @@ function parseReference(s: ITokenStream): Ast.Node {
 		if (segs.length > 0) {
 			if (s.kind === TokenKind.Colon) {
 				if (s.token.hasLeftSpacing) {
-					throw new AiScriptSyntaxError('Cannot use spaces in a reference.');
+					throw new AiScriptSyntaxError('Cannot use spaces in a reference.', s.token.loc);
 				}
 				s.next();
 				if (s.token.hasLeftSpacing) {
-					throw new AiScriptSyntaxError('Cannot use spaces in a reference.');
+					throw new AiScriptSyntaxError('Cannot use spaces in a reference.', s.token.loc);
 				}
 			} else {
 				break;
@@ -505,7 +505,7 @@ function parseObject(s: ITokenStream, isStatic: boolean): Ast.Node {
 			// noop
 		} else {
 			if (!s.token.hasLeftSpacing) {
-				throw new AiScriptSyntaxError('separator expected');
+				throw new AiScriptSyntaxError('separator expected', s.token.loc);
 			}
 		}
 
@@ -546,7 +546,7 @@ function parseArray(s: ITokenStream, isStatic: boolean): Ast.Node {
 			// noop
 		} else {
 			if (!s.token.hasLeftSpacing) {
-				throw new AiScriptSyntaxError('separator expected');
+				throw new AiScriptSyntaxError('separator expected', s.token.loc);
 			}
 		}
 
diff --git a/src/parser/syntaxes/statements.ts b/src/parser/syntaxes/statements.ts
@@ -72,7 +72,7 @@ export function parseDefStatement(s: ITokenStream): Ast.Node {
 			return parseFnDef(s);
 		}
 		default: {
-			throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[s.kind]}`);
+			throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[s.kind]}`, s.token.loc);
 		}
 	}
 }
@@ -112,7 +112,7 @@ function parseVarDef(s: ITokenStream): Ast.Node {
 			break;
 		}
 		default: {
-			throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[s.kind]}`);
+			throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[s.kind]}`, s.token.loc);
 		}
 	}
 	s.next();
@@ -213,7 +213,7 @@ function parseEach(s: ITokenStream): Ast.Node {
 	if (s.kind === TokenKind.Comma) {
 		s.next();
 	} else if (!s.token.hasLeftSpacing) {
-		throw new AiScriptSyntaxError('separator expected');
+		throw new AiScriptSyntaxError('separator expected', s.token.loc);
 	}
 
 	const items = parseExpr(s, false);
@@ -263,7 +263,7 @@ function parseFor(s: ITokenStream): Ast.Node {
 		if ((s.kind as TokenKind) === TokenKind.Comma) {
 			s.next();
 		} else if (!s.token.hasLeftSpacing) {
-			throw new AiScriptSyntaxError('separator expected');
+			throw new AiScriptSyntaxError('separator expected', s.token.loc);
 		}
 
 		const to = parseExpr(s, false);
@@ -326,7 +326,7 @@ function parseStatementWithAttr(s: ITokenStream): Ast.Node {
 	const statement = parseStatement(s);
 
 	if (statement.type !== 'def') {
-		throw new AiScriptSyntaxError('invalid attribute.');
+		throw new AiScriptSyntaxError('invalid attribute.', statement.loc);
 	}
 	if (statement.attr != null) {
 		statement.attr.push(...attrs);
diff --git a/src/parser/syntaxes/toplevel.ts b/src/parser/syntaxes/toplevel.ts
@@ -36,7 +36,7 @@ export function parseTopLevel(s: ITokenStream): Ast.Node[] {
 		}
 
 		if ((s.kind as TokenKind) !== TokenKind.NewLine && (s.kind as TokenKind) !== TokenKind.EOF) {
-			throw new AiScriptSyntaxError('Multiple statements cannot be placed on a single line.');
+			throw new AiScriptSyntaxError('Multiple statements cannot be placed on a single line.', s.token.loc);
 		}
 		while ((s.kind as TokenKind) === TokenKind.NewLine) {
 			s.next();
@@ -82,7 +82,7 @@ export function parseNamespace(s: ITokenStream): Ast.Node {
 		}
 
 		if ((s.kind as TokenKind) !== TokenKind.NewLine && (s.kind as TokenKind) !== TokenKind.CloseBrace) {
-			throw new AiScriptSyntaxError('Multiple statements cannot be placed on a single line.');
+			throw new AiScriptSyntaxError('Multiple statements cannot be placed on a single line.', s.token.loc);
 		}
 		while ((s.kind as TokenKind) === TokenKind.NewLine) {
 			s.next();
diff --git a/src/type.ts b/src/type.ts
@@ -151,7 +151,7 @@ export function getTypeBySource(typeSource: Ast.TypeSource): Type {
 				return T_GENERIC(typeSource.name, [innerType]);
 			}
 		}
-		throw new AiScriptSyntaxError(`Unknown type: '${getTypeNameBySource(typeSource)}'`);
+		throw new AiScriptSyntaxError(`Unknown type: '${getTypeNameBySource(typeSource)}'`, typeSource.loc);
 	} else {
 		const argTypes = typeSource.args.map(arg => getTypeBySource(arg));
 		return T_FN(argTypes, getTypeBySource(typeSource.result));

Original file line number	Diff line number	Diff line change
`@@ -42,8 +42,8 @@ const reservedWord = [`
`42`	`42`	`// 'out',`
`43`	`43`	`];`
`44`	`44`
`45`		`-function throwReservedWordError(name: string): void {`
`46`		- throw new AiScriptSyntaxError(`Reserved word "${name}" cannot be used as variable name.`);
	`45`	`+function throwReservedWordError(name: string, loc: Ast.Loc): void {`
	`46`	+ throw new AiScriptSyntaxError(`Reserved word "${name}" cannot be used as variable name.`, loc);
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`function validateNode(node: Ast.Node): Ast.Node {`
`@@ -53,20 +53,20 @@ function validateNode(node: Ast.Node): Ast.Node {`
`53`	`53`	`case 'ns':`
`54`	`54`	`case 'identifier': {`
`55`	`55`	`if (reservedWord.includes(node.name)) {`
`56`		`- throwReservedWordError(node.name);`
	`56`	`+ throwReservedWordError(node.name, node.loc);`
`57`	`57`	`}`
`58`	`58`	`break;`
`59`	`59`	`}`
`60`	`60`	`case 'meta': {`
`61`	`61`	`if (node.name != null && reservedWord.includes(node.name)) {`
`62`		`- throwReservedWordError(node.name);`
	`62`	`+ throwReservedWordError(node.name, node.loc);`
`63`	`63`	`}`
`64`	`64`	`break;`
`65`	`65`	`}`
`66`	`66`	`case 'fn': {`
`67`	`67`	`for (const arg of node.args) {`
`68`	`68`	`if (reservedWord.includes(arg.name)) {`
`69`		`- throwReservedWordError(arg.name);`
	`69`	`+ throwReservedWordError(arg.name, node.loc);`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`	`break;`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ export class Scanner implements ITokenStream {`
`75`	`75`	`*/`
`76`	`76`	`public expect(kind: TokenKind): void {`
`77`	`77`	`if (this.kind !== kind) {`
`78`		- throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[this.kind]}`);
	`78`	+ throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[this.kind]}`, this.token.loc);
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
`@@ -140,7 +140,7 @@ export class Scanner implements ITokenStream {`
`140`	`140`	`this.stream.next();`
`141`	`141`	`token = TOKEN(TokenKind.OpenSharpBracket, loc, { hasLeftSpacing });`
`142`	`142`	`} else {`
`143`		`- throw new AiScriptSyntaxError('invalid character: "#"');`
	`143`	`+ throw new AiScriptSyntaxError('invalid character: "#"', loc);`
`144`	`144`	`}`
`145`	`145`	`break;`
`146`	`146`	`}`
`@@ -327,7 +327,7 @@ export class Scanner implements ITokenStream {`
`327`	`327`	`token = wordToken;`
`328`	`328`	`break;`
`329`	`329`	`}`
`330`		- throw new AiScriptSyntaxError(`invalid character: "${this.stream.char}"`);
	`330`	+ throw new AiScriptSyntaxError(`invalid character: "${this.stream.char}"`, loc);
`331`	`331`	`}`
`332`	`332`	`break;`
`333`	`333`	`}`
`@@ -432,7 +432,7 @@ export class Scanner implements ITokenStream {`
`432`	`432`	`this.stream.next();`
`433`	`433`	`}`
`434`	`434`	`if (fractional.length === 0) {`
`435`		`- throw new AiScriptSyntaxError('digit expected');`
	`435`	`+ throw new AiScriptSyntaxError('digit expected', loc);`
`436`	`436`	`}`
`437`	`437`	`}`
`438`	`438`	`let value;`
`@@ -456,7 +456,7 @@ export class Scanner implements ITokenStream {`
`456`	`456`	`switch (state) {`
`457`	`457`	`case 'string': {`
`458`	`458`	`if (this.stream.eof) {`
`459`		`- throw new AiScriptSyntaxError('unexpected EOF');`
	`459`	`+ throw new AiScriptSyntaxError('unexpected EOF', loc);`
`460`	`460`	`}`
`461`	`461`	`if (this.stream.char === '\\') {`
`462`	`462`	`this.stream.next();`
`@@ -474,7 +474,7 @@ export class Scanner implements ITokenStream {`
`474`	`474`	`}`
`475`	`475`	`case 'escape': {`
`476`	`476`	`if (this.stream.eof) {`
`477`		`- throw new AiScriptSyntaxError('unexpected EOF');`
	`477`	`+ throw new AiScriptSyntaxError('unexpected EOF', loc);`
`478`	`478`	`}`
`479`	`479`	`value += this.stream.char;`
`480`	`480`	`this.stream.next();`
`@@ -501,7 +501,7 @@ export class Scanner implements ITokenStream {`
`501`	`501`	`case 'string': {`
`502`	`502`	`// テンプレートの終了が無いままEOFに達した`
`503`	`503`	`if (this.stream.eof) {`
`504`		`- throw new AiScriptSyntaxError('unexpected EOF');`
	`504`	`+ throw new AiScriptSyntaxError('unexpected EOF', loc);`
`505`	`505`	`}`
`506`	`506`	`// エスケープ`
`507`	`507`	`if (this.stream.char === '\\') {`
`@@ -537,7 +537,7 @@ export class Scanner implements ITokenStream {`
`537`	`537`	`case 'escape': {`
`538`	`538`	`// エスケープ対象の文字が無いままEOFに達した`
`539`	`539`	`if (this.stream.eof) {`
`540`		`- throw new AiScriptSyntaxError('unexpected EOF');`
	`540`	`+ throw new AiScriptSyntaxError('unexpected EOF', loc);`
`541`	`541`	`}`
`542`	`542`	`// 普通の文字として取り込み`
`543`	`543`	`buf += this.stream.char;`
`@@ -549,7 +549,7 @@ export class Scanner implements ITokenStream {`
`549`	`549`	`case 'expr': {`
`550`	`550`	`// 埋め込み式の終端記号が無いままEOFに達した`
`551`	`551`	`if (this.stream.eof) {`
`552`		`- throw new AiScriptSyntaxError('unexpected EOF');`
	`552`	`+ throw new AiScriptSyntaxError('unexpected EOF', loc);`
`553`	`553`	`}`
`554`	`554`	`// skip spasing`
`555`	`555`	`if (spaceChars.includes(this.stream.char)) {`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ export class TokenStream implements ITokenStream {`
`101`	`101`	`*/`
`102`	`102`	`public expect(kind: TokenKind): void {`
`103`	`103`	`if (this.kind !== kind) {`
`104`		- throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[this.kind]}`);
	`104`	+ throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[this.kind]}`, this.token.loc);
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ export function parseParams(s: ITokenStream): { name: string, argType?: Ast.Node`
`22`	`22`	`if (s.kind === TokenKind.Comma) {`
`23`	`23`	`s.next();`
`24`	`24`	`} else if (!s.token.hasLeftSpacing) {`
`25`		`- throw new AiScriptSyntaxError('separator expected');`
	`25`	`+ throw new AiScriptSyntaxError('separator expected', s.token.loc);`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
`@@ -61,7 +61,7 @@ export function parseBlock(s: ITokenStream): Ast.Node[] {`
`61`	`61`	`steps.push(parseStatement(s));`
`62`	`62`
`63`	`63`	`if ((s.kind as TokenKind) !== TokenKind.NewLine && (s.kind as TokenKind) !== TokenKind.CloseBrace) {`
`64`		`- throw new AiScriptSyntaxError('Multiple statements cannot be placed on a single line.');`
	`64`	`+ throw new AiScriptSyntaxError('Multiple statements cannot be placed on a single line.', s.token.loc);`
`65`	`65`	`}`
`66`	`66`	`while ((s.kind as TokenKind) === TokenKind.NewLine) {`
`67`	`67`	`s.next();`
`@@ -101,7 +101,7 @@ function parseFnType(s: ITokenStream): Ast.Node {`
`101`	`101`	`if (s.kind === TokenKind.Comma) {`
`102`	`102`	`s.next();`
`103`	`103`	`} else if (!s.token.hasLeftSpacing) {`
`104`		`- throw new AiScriptSyntaxError('separator expected');`
	`104`	`+ throw new AiScriptSyntaxError('separator expected', s.token.loc);`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`	`const type = parseType(s);`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ function parsePrefix(s: ITokenStream, minBp: number): Ast.Node {`
`70`	`70`	`if (expr.type === 'num') {`
`71`	`71`	`return NODE('num', { value: expr.value }, loc);`
`72`	`72`	`} else {`
`73`		`- throw new AiScriptSyntaxError('currently, sign is only supported for number literal.');`
	`73`	`+ throw new AiScriptSyntaxError('currently, sign is only supported for number literal.', loc);`
`74`	`74`	`}`
`75`	`75`	`// TODO: 将来的にサポートされる式を拡張`
`76`	`76`	`// return NODE('plus', { expr }, loc);`
`@@ -80,7 +80,7 @@ function parsePrefix(s: ITokenStream, minBp: number): Ast.Node {`
`80`	`80`	`if (expr.type === 'num') {`
`81`	`81`	`return NODE('num', { value: -1 * expr.value }, loc);`
`82`	`82`	`} else {`
`83`		`- throw new AiScriptSyntaxError('currently, sign is only supported for number literal.');`
	`83`	`+ throw new AiScriptSyntaxError('currently, sign is only supported for number literal.', loc);`
`84`	`84`	`}`
`85`	`85`	`// TODO: 将来的にサポートされる式を拡張`
`86`	`86`	`// return NODE('minus', { expr }, loc);`
`@@ -89,7 +89,7 @@ function parsePrefix(s: ITokenStream, minBp: number): Ast.Node {`
`89`	`89`	`return NODE('not', { expr }, loc);`
`90`	`90`	`}`
`91`	`91`	`default: {`
`92`		- throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[op]}`);
	`92`	+ throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[op]}`, loc);
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`	`}`
`@@ -161,7 +161,7 @@ function parseInfix(s: ITokenStream, left: Ast.Node, minBp: number): Ast.Node {`
`161`	`161`	`return NODE('or', { left, right }, loc);`
`162`	`162`	`}`
`163`	`163`	`default: {`
`164`		- throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[op]}`);
	`164`	+ throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[op]}`, loc);
`165`	`165`	`}`
`166`	`166`	`}`
`167`	`167`	`}`
`@@ -186,7 +186,7 @@ function parsePostfix(s: ITokenStream, expr: Ast.Node): Ast.Node {`
`186`	`186`	`}, loc);`
`187`	`187`	`}`
`188`	`188`	`default: {`
`189`		- throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[op]}`);
	`189`	+ throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[op]}`, loc);
`190`	`190`	`}`
`191`	`191`	`}`
`192`	`192`	`}`
`@@ -231,13 +231,13 @@ function parseAtom(s: ITokenStream, isStatic: boolean): Ast.Node {`
`231`	`231`	`const exprStream = new TokenStream(element.children!);`
`232`	`232`	`const expr = parseExpr(exprStream, false);`
`233`	`233`	`if (exprStream.kind !== TokenKind.EOF) {`
`234`		- throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[exprStream.token.kind]}`);
	`234`	+ throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[exprStream.token.kind]}`, exprStream.token.loc);
`235`	`235`	`}`
`236`	`236`	`values.push(expr);`
`237`	`237`	`break;`
`238`	`238`	`}`
`239`	`239`	`default: {`
`240`		- throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[element.kind]}`);
	`240`	+ throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[element.kind]}`, element.loc);
`241`	`241`	`}`
`242`	`242`	`}`
`243`	`243`	`}`
`@@ -283,7 +283,7 @@ function parseAtom(s: ITokenStream, isStatic: boolean): Ast.Node {`
`283`	`283`	`return expr;`
`284`	`284`	`}`
`285`	`285`	`}`
`286`		- throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[s.kind]}`);
	`286`	+ throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[s.kind]}`, loc);
`287`	`287`	`}`
`288`	`288`
`289`	`289`	`/**`
`@@ -301,7 +301,7 @@ function parseCall(s: ITokenStream, target: Ast.Node): Ast.Node {`
`301`	`301`	`if (s.kind === TokenKind.Comma) {`
`302`	`302`	`s.next();`
`303`	`303`	`} else if (!s.token.hasLeftSpacing) {`
`304`		`- throw new AiScriptSyntaxError('separator expected');`
	`304`	`+ throw new AiScriptSyntaxError('separator expected', s.token.loc);`
`305`	`305`	`}`
`306`	`306`	`}`
`307`	`307`
`@@ -451,11 +451,11 @@ function parseReference(s: ITokenStream): Ast.Node {`
`451`	`451`	`if (segs.length > 0) {`
`452`	`452`	`if (s.kind === TokenKind.Colon) {`
`453`	`453`	`if (s.token.hasLeftSpacing) {`
`454`		`- throw new AiScriptSyntaxError('Cannot use spaces in a reference.');`
	`454`	`+ throw new AiScriptSyntaxError('Cannot use spaces in a reference.', s.token.loc);`
`455`	`455`	`}`
`456`	`456`	`s.next();`
`457`	`457`	`if (s.token.hasLeftSpacing) {`
`458`		`- throw new AiScriptSyntaxError('Cannot use spaces in a reference.');`
	`458`	`+ throw new AiScriptSyntaxError('Cannot use spaces in a reference.', s.token.loc);`
`459`	`459`	`}`
`460`	`460`	`} else {`
`461`	`461`	`break;`
`@@ -505,7 +505,7 @@ function parseObject(s: ITokenStream, isStatic: boolean): Ast.Node {`
`505`	`505`	`// noop`
`506`	`506`	`} else {`
`507`	`507`	`if (!s.token.hasLeftSpacing) {`
`508`		`- throw new AiScriptSyntaxError('separator expected');`
	`508`	`+ throw new AiScriptSyntaxError('separator expected', s.token.loc);`
`509`	`509`	`}`
`510`	`510`	`}`
`511`	`511`
`@@ -546,7 +546,7 @@ function parseArray(s: ITokenStream, isStatic: boolean): Ast.Node {`
`546`	`546`	`// noop`
`547`	`547`	`} else {`
`548`	`548`	`if (!s.token.hasLeftSpacing) {`
`549`		`- throw new AiScriptSyntaxError('separator expected');`
	`549`	`+ throw new AiScriptSyntaxError('separator expected', s.token.loc);`
`550`	`550`	`}`
`551`	`551`	`}`
`552`	`552`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ export function parseDefStatement(s: ITokenStream): Ast.Node {`
`72`	`72`	`return parseFnDef(s);`
`73`	`73`	`}`
`74`	`74`	`default: {`
`75`		- throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[s.kind]}`);
	`75`	+ throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[s.kind]}`, s.token.loc);
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`	`}`
`@@ -112,7 +112,7 @@ function parseVarDef(s: ITokenStream): Ast.Node {`
`112`	`112`	`break;`
`113`	`113`	`}`
`114`	`114`	`default: {`
`115`		- throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[s.kind]}`);
	`115`	+ throw new AiScriptSyntaxError(`unexpected token: ${TokenKind[s.kind]}`, s.token.loc);
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`	`s.next();`
`@@ -213,7 +213,7 @@ function parseEach(s: ITokenStream): Ast.Node {`
`213`	`213`	`if (s.kind === TokenKind.Comma) {`
`214`	`214`	`s.next();`
`215`	`215`	`} else if (!s.token.hasLeftSpacing) {`
`216`		`- throw new AiScriptSyntaxError('separator expected');`
	`216`	`+ throw new AiScriptSyntaxError('separator expected', s.token.loc);`
`217`	`217`	`}`
`218`	`218`
`219`	`219`	`const items = parseExpr(s, false);`
`@@ -263,7 +263,7 @@ function parseFor(s: ITokenStream): Ast.Node {`
`263`	`263`	`if ((s.kind as TokenKind) === TokenKind.Comma) {`
`264`	`264`	`s.next();`
`265`	`265`	`} else if (!s.token.hasLeftSpacing) {`
`266`		`- throw new AiScriptSyntaxError('separator expected');`
	`266`	`+ throw new AiScriptSyntaxError('separator expected', s.token.loc);`
`267`	`267`	`}`
`268`	`268`
`269`	`269`	`const to = parseExpr(s, false);`
`@@ -326,7 +326,7 @@ function parseStatementWithAttr(s: ITokenStream): Ast.Node {`
`326`	`326`	`const statement = parseStatement(s);`
`327`	`327`
`328`	`328`	`if (statement.type !== 'def') {`
`329`		`- throw new AiScriptSyntaxError('invalid attribute.');`
	`329`	`+ throw new AiScriptSyntaxError('invalid attribute.', statement.loc);`
`330`	`330`	`}`
`331`	`331`	`if (statement.attr != null) {`
`332`	`332`	`statement.attr.push(...attrs);`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ export function parseTopLevel(s: ITokenStream): Ast.Node[] {`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`if ((s.kind as TokenKind) !== TokenKind.NewLine && (s.kind as TokenKind) !== TokenKind.EOF) {`
`39`		`- throw new AiScriptSyntaxError('Multiple statements cannot be placed on a single line.');`
	`39`	`+ throw new AiScriptSyntaxError('Multiple statements cannot be placed on a single line.', s.token.loc);`
`40`	`40`	`}`
`41`	`41`	`while ((s.kind as TokenKind) === TokenKind.NewLine) {`
`42`	`42`	`s.next();`
`@@ -82,7 +82,7 @@ export function parseNamespace(s: ITokenStream): Ast.Node {`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`if ((s.kind as TokenKind) !== TokenKind.NewLine && (s.kind as TokenKind) !== TokenKind.CloseBrace) {`
`85`		`- throw new AiScriptSyntaxError('Multiple statements cannot be placed on a single line.');`
	`85`	`+ throw new AiScriptSyntaxError('Multiple statements cannot be placed on a single line.', s.token.loc);`
`86`	`86`	`}`
`87`	`87`	`while ((s.kind as TokenKind) === TokenKind.NewLine) {`
`88`	`88`	`s.next();`
Original file line number	Diff line number	Diff line change
`@@ -151,7 +151,7 @@ export function getTypeBySource(typeSource: Ast.TypeSource): Type {`
`151`	`151`	`return T_GENERIC(typeSource.name, [innerType]);`
`152`	`152`	`}`
`153`	`153`	`}`
`154`		- throw new AiScriptSyntaxError(`Unknown type: '${getTypeNameBySource(typeSource)}'`);
	`154`	+ throw new AiScriptSyntaxError(`Unknown type: '${getTypeNameBySource(typeSource)}'`, typeSource.loc);
`155`	`155`	`} else {`
`156`	`156`	`const argTypes = typeSource.args.map(arg => getTypeBySource(arg));`
`157`	`157`	`return T_FN(argTypes, getTypeBySource(typeSource.result));`