ifの条件やmatchのターゲットとパターンでbreakできないように

Author: takejohn

src/interpreter/index.ts

@@ -367,7 +367,7 @@ export class Interpreter {
 			case 'if': {
 				const cond = await this._eval(node.cond, scope, callStack);
 				if (isControl(cond)) {
-					return unWrapLabeledBreak(cond, node.label);
+					return cond;
 				}
 				assertBoolean(cond);
 				if (cond.value) {
@@ -392,7 +392,7 @@ export class Interpreter {
 			case 'match': {
 				const about = await this._eval(node.about, scope, callStack);
 				if (isControl(about)) {
-					return unWrapLabeledBreak(about, node.label);
+					return about;
 				}
 				for (const qa of node.qs) {
 					const q = await this._eval(qa.q, scope, callStack);

src/parser/plugins/validate-jump-statements.ts

@@ -45,7 +45,41 @@ function validateNode(node: Ast.Node, ancestors: Ast.Node[]): Ast.Node {
 					throw new AiScriptSyntaxError(`label "${node.label}" is not defined`, node.loc.start);
 				}
 				throw new AiScriptSyntaxError('unlabeled break must be inside for / each / while / do-while / loop', node.loc.start);
-			} else if (node.expr != null) {
+			}
+
+			switch (block.type) {
+				case 'each': {
+					if (ancestors.includes(block.items)) {
+						throw new AiScriptSyntaxError('break corresponding to each is not allowed in the target', node.loc.start);
+					}
+					break;
+				}
+				case 'for': {
+					if (block.times != null && ancestors.includes(block.times)) {
+						throw new AiScriptSyntaxError('break corresponding to for is not allowed in the count', node.loc.start);
+					} else if (ancestors.some((ancestor) => ancestor === block.from || ancestor === block.to)) {
+						throw new AiScriptSyntaxError('break corresponding to for is not allowed in the range', node.loc.start);
+					}
+					break;
+				}
+				case 'if': {
+					if (ancestors.includes(block.cond)) {
+						throw new AiScriptSyntaxError('break corresponding to if is not allowed in the condition', node.loc.start);
+					}
+					break;
+				}
+				case 'match':{
+					if (ancestors.includes(block.about)) {
+						throw new AiScriptSyntaxError('break corresponding to match is not allowed in the target', node.loc.start);
+					}
+					if (block.qs.some(({ q }) => ancestors.includes(q))) {
+						throw new AiScriptSyntaxError('break corresponding to match is not allowed in the pattern', node.loc.start);
+					}
+					break;
+				}
+			}
+
+			if (node.expr != null) {
 				switch (block.type) {
 					case 'if':
 					case 'match':

test/jump-statements.ts

@@ -673,6 +673,57 @@ describe('break', () => {
 		);
 	});
 
+	test.concurrent('break corresponding to each is not allowed in the target', async () => {
+		await assert.rejects(
+			() => exe('#l: each let i, eval { break #l } {}'),
+			new AiScriptSyntaxError('break corresponding to each is not allowed in the target', { line: 1, column: 24 }),
+		);
+	});
+
+	test.concurrent('break corresponding to for is not allowed in the count', async () => {
+		await assert.rejects(
+			() => exe('#l: for eval { break #l } {}'),
+			new AiScriptSyntaxError('break corresponding to for is not allowed in the count', { line: 1, column: 16 }),
+		);
+	});
+
+	describe('break corresponding to for is not allowed in the range', () => {
+		test.concurrent('from', async () => {
+			await assert.rejects(
+				() => exe('#l: for let i = eval { break #l }, 0 {}'),
+				new AiScriptSyntaxError('break corresponding to for is not allowed in the range', { line: 1, column: 24 }),
+			);
+		});
+
+		test.concurrent('to', async () => {
+			await assert.rejects(
+				() => exe('#l: for let i = 0, eval { break #l } {}'),
+				new AiScriptSyntaxError('break corresponding to for is not allowed in the range', { line: 1, column: 27 }),
+			);
+		});
+	});
+
+	test.concurrent('break corresponding to if is not allowed in the condition', async () => {
+		await assert.rejects(
+			() => exe('#l: if eval { break #l } {}'),
+			new AiScriptSyntaxError('break corresponding to if is not allowed in the condition', { line: 1, column: 15 }),
+		);
+	});
+
+	test.concurrent('break corresponding to match is not allowed in the target', async () => {
+		await assert.rejects(
+			() => exe('#l: match eval { break #l } {}'),
+			new AiScriptSyntaxError('break corresponding to match is not allowed in the target', { line: 1, column: 18 }),
+		);
+	});
+
+	test.concurrent('break corresponding to match is not allowed in the pattern', async () => {
+		await assert.rejects(
+			() => exe('#l: match 0 { case eval { break #l } => 1 }'),
+			new AiScriptSyntaxError('break corresponding to match is not allowed in the pattern', { line: 1, column: 27 }),
+		);
+	});
+
 	describe('labeled each', () => {
 		test.concurrent('inner each', async () => {
 			const res = await exe(`