redscript-mc 1.2.10 → 1.2.12

package/dist/__tests__/dce.test.js

@@ -46,15 +46,16 @@ function getFileContent(files, suffix) {
     return file.content;
 }
 describe('AST dead code elimination', () => {
-    it('removes unused functions reachable from entry points', () => {
+    it('removes private unused functions (prefixed with _)', () => {
         const source = `
-fn unused() { say("never called"); }
+fn _unused() { say("never called"); }
 fn used() { say("called"); }
 @tick fn main() { used(); }
 `;
         const result = (0, index_1.compile)(source, { namespace: 'test' });
+        // _unused is removed because it starts with _ (private) and is not called
         expect(result.ast.declarations.map(fn => fn.name)).toEqual(['used', 'main']);
-        expect(result.ir.functions.some(fn => fn.name === 'unused')).toBe(false);
+        expect(result.ir.functions.some(fn => fn.name === '_unused')).toBe(false);
     });
     it('removes unused local variables from the AST body', () => {
         const source = `

package/dist/__tests__/e2e.test.js

@@ -171,8 +171,8 @@ fn main() {
             const foreachFn = getSubFunction(files, 'main', 'foreach_0');
             const thenFiles = files.filter(file => file.path.includes('/main/then_') && file.content.includes('kill @s'));
             expect(mainFn).toContain('execute as @e run function test:main/foreach_0');
-            expect(foreachFn).toContain('execute if entity @s[type=player] run function test:main/then_');
-            expect(foreachFn).toContain('execute if entity @s[type=zombie] run function test:main/then_');
+            expect(foreachFn).toContain('execute if entity @s[type=minecraft:player] run function test:main/then_');
+            expect(foreachFn).toContain('execute if entity @s[type=minecraft:zombie] run function test:main/then_');
             expect(thenFiles).toHaveLength(2);
         });
     });

package/dist/__tests__/lowering.test.js

@@ -251,7 +251,7 @@ fn scan() {
 `);
             const foreachFn = ir.functions.find(fn => fn.name.includes('scan/foreach'));
             const rawCmds = getRawCommands(foreachFn);
-            const isCheckCmd = rawCmds.find(cmd => cmd.startsWith('execute if entity @s[type=player] run function test:scan/then_'));
+            const isCheckCmd = rawCmds.find(cmd => cmd.startsWith('execute if entity @s[type=minecraft:player] run function test:scan/then_'));
             expect(isCheckCmd).toBeDefined();
             const thenFn = ir.functions.find(fn => fn.name.startsWith('scan/then_'));
             expect(getRawCommands(thenFn)).toContain('kill @s');
@@ -315,8 +315,8 @@ fn test() {
             const [playerThenFn, zombieThenFn] = thenFns;
             expect(getRawCommands(mainFn)).toContain('execute as @e run function test:test/foreach_0');
             expect(thenFns).toHaveLength(2);
-            expect(rawCmds).toContain(`execute if entity @s[type=player] run function test:${playerThenFn.name}`);
-            expect(rawCmds).toContain(`execute if entity @s[type=zombie] run function test:${zombieThenFn.name}`);
+            expect(rawCmds).toContain(`execute if entity @s[type=minecraft:player] run function test:${playerThenFn.name}`);
+            expect(rawCmds).toContain(`execute if entity @s[type=minecraft:zombie] run function test:${zombieThenFn.name}`);
             expect(getRawCommands(playerThenFn).some(cmd => cmd.includes('give @s diamond 1'))).toBe(true);
             expect(getRawCommands(zombieThenFn)).toContain('kill @s');
         });

package/dist/__tests__/mc-integration.test.js

@@ -694,28 +694,28 @@ describe('MC Integration - New Features', () => {
         expect(count).toBeGreaterThanOrEqual(3);
         expect(count).toBeLessThanOrEqual(3);
     });
-    test('is-check-test.mcrs: foreach is-narrowing only matches zombie entities', async () => {
+    test('is-check-test.mcrs: foreach is-narrowing correctly matches entity types', async () => {
         if (!serverOnline)
             return;
         await mc.fullReset({ clearArea: false, killEntities: true, resetScoreboards: false });
-        await mc.command('/scoreboard players set #is_check players 0');
-        await mc.command('/scoreboard players set #is_check zombies 0');
+        await mc.command('/forceload add 0 0').catch(() => { }); // Ensure chunk is loaded
+        await mc.command('/scoreboard objectives add armor_stands dummy').catch(() => { });
+        await mc.command('/scoreboard objectives add items dummy').catch(() => { });
+        await mc.command('/scoreboard players set #is_check armor_stands 0');
+        await mc.command('/scoreboard players set #is_check items 0');
         await mc.command('/function is_check_test:__load').catch(() => { });
-        await mc.command('/summon minecraft:zombie 0 65 0');
-        await mc.command('/tag @e[type=minecraft:zombie,sort=nearest,limit=1] add is_check_target');
-        await mc.command('/summon minecraft:armor_stand 2 65 0');
-        await mc.command('/tag @e[type=minecraft:armor_stand,sort=nearest,limit=1] add is_check_target');
+        // Spawn 2 armor_stands and 1 item (all persist without players)
+        await mc.command('/summon minecraft:armor_stand 0 65 0 {Tags:["is_check_target"],NoGravity:1b}');
+        await mc.command('/summon minecraft:armor_stand 2 65 0 {Tags:["is_check_target"],NoGravity:1b}');
+        await mc.command('/summon minecraft:item 4 65 0 {Tags:["is_check_target"],Item:{id:"minecraft:stone",count:1},Age:-32768}');
+        await mc.ticks(5);
         await mc.command('/function is_check_test:check_types');
         await mc.ticks(5);
-        const zombies = await mc.scoreboard('#is_check', 'zombies');
-        const players = await mc.scoreboard('#is_check', 'players');
-        const zombieEntities = await mc.entities('@e[type=minecraft:zombie,tag=is_check_target]');
-        const standEntities = await mc.entities('@e[type=minecraft:armor_stand,tag=is_check_target]');
-        expect(zombies).toBe(1);
-        expect(players).toBe(0);
-        expect(zombieEntities).toHaveLength(0);
-        expect(standEntities).toHaveLength(1);
-        await mc.command('/kill @e[tag=is_check_target]').catch(() => { });
+        const armorStands = await mc.scoreboard('#is_check', 'armor_stands');
+        const items = await mc.scoreboard('#is_check', 'items');
+        expect(armorStands).toBe(2); // 2 armor_stands matched
+        expect(items).toBe(1); // 1 item matched
+        await mc.command('/function is_check_test:cleanup').catch(() => { });
     });
     test('event-test.mcrs: @on(PlayerDeath) compiles and loads', async () => {
         if (!serverOnline)
@@ -731,4 +731,89 @@ describe('MC Integration - New Features', () => {
         expect(tickResult.ok).toBe(true);
     });
 });
+describe('MC Integration - Extended Coverage', () => {
+    test('struct-test.mcrs: struct instantiation and field access', async () => {
+        if (!serverOnline)
+            return;
+        writeFixtureFile('struct-test.mcrs', 'struct_test');
+        await mc.reload();
+        await mc.command('/function struct_test:__load').catch(() => { });
+        await mc.command('/function struct_test:test_struct');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#struct_x', 'rs')).toBe(10);
+        expect(await mc.scoreboard('#struct_y', 'rs')).toBe(64);
+        expect(await mc.scoreboard('#struct_z', 'rs')).toBe(-5);
+        expect(await mc.scoreboard('#struct_x2', 'rs')).toBe(15); // 10+5
+        expect(await mc.scoreboard('#struct_z2', 'rs')).toBe(-10); // -5*2
+        expect(await mc.scoreboard('#struct_alive', 'rs')).toBe(1);
+        expect(await mc.scoreboard('#struct_score', 'rs')).toBe(100);
+    });
+    test('enum-test.mcrs: enum values and match', async () => {
+        if (!serverOnline)
+            return;
+        writeFixtureFile('enum-test.mcrs', 'enum_test');
+        await mc.reload();
+        await mc.command('/function enum_test:__load').catch(() => { });
+        await mc.command('/function enum_test:test_enum');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#enum_phase', 'rs')).toBe(2); // Playing=2
+        expect(await mc.scoreboard('#enum_match', 'rs')).toBe(2); // matched Playing
+        expect(await mc.scoreboard('#enum_rank', 'rs')).toBe(10); // Diamond=10
+        expect(await mc.scoreboard('#enum_high', 'rs')).toBe(1); // Diamond > Gold
+    });
+    test('array-test.mcrs: array operations', async () => {
+        if (!serverOnline)
+            return;
+        writeFixtureFile('array-test.mcrs', 'array_test');
+        await mc.reload();
+        await mc.command('/function array_test:__load').catch(() => { });
+        await mc.command('/function array_test:test_array');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#arr_0', 'rs')).toBe(10);
+        expect(await mc.scoreboard('#arr_2', 'rs')).toBe(30);
+        expect(await mc.scoreboard('#arr_4', 'rs')).toBe(50);
+        expect(await mc.scoreboard('#arr_len', 'rs')).toBe(5);
+        expect(await mc.scoreboard('#arr_sum', 'rs')).toBe(150); // 10+20+30+40+50
+        expect(await mc.scoreboard('#arr_push', 'rs')).toBe(4); // [1,2,3,4].len
+        expect(await mc.scoreboard('#arr_pop', 'rs')).toBe(4); // popped value
+    });
+    test('break-continue-test.mcrs: break and continue statements', async () => {
+        if (!serverOnline)
+            return;
+        writeFixtureFile('break-continue-test.mcrs', 'break_continue_test');
+        await mc.reload();
+        await mc.command('/function break_continue_test:__load').catch(() => { });
+        await mc.command('/function break_continue_test:test_break_continue');
+        await mc.ticks(10);
+        expect(await mc.scoreboard('#break_at', 'rs')).toBe(5);
+        expect(await mc.scoreboard('#sum_evens', 'rs')).toBe(20); // 0+2+4+6+8
+        expect(await mc.scoreboard('#while_break', 'rs')).toBe(7);
+        expect(await mc.scoreboard('#nested_break', 'rs')).toBe(3); // outer completes 3 times
+    });
+    test('match-range-test.mcrs: match with range patterns', async () => {
+        if (!serverOnline)
+            return;
+        writeFixtureFile('match-range-test.mcrs', 'match_range_test');
+        await mc.reload();
+        await mc.command('/function match_range_test:__load').catch(() => { });
+        await mc.command('/function match_range_test:test_match_range');
+        await mc.ticks(5);
+        expect(await mc.scoreboard('#grade', 'rs')).toBe(4); // score=85 → B
+        expect(await mc.scoreboard('#boundary_59', 'rs')).toBe(1); // 59 matches 0..59
+        expect(await mc.scoreboard('#boundary_60', 'rs')).toBe(2); // 60 matches 60..100
+        expect(await mc.scoreboard('#neg_range', 'rs')).toBe(1); // -5 matches ..0
+    });
+    test('foreach-at-test.mcrs: foreach with at @s context', async () => {
+        if (!serverOnline)
+            return;
+        writeFixtureFile('foreach-at-test.mcrs', 'foreach_at_test');
+        await mc.reload();
+        await mc.fullReset({ clearArea: false, killEntities: true, resetScoreboards: false });
+        await mc.command('/function foreach_at_test:setup').catch(() => { });
+        await mc.command('/function foreach_at_test:test_foreach_at');
+        await mc.ticks(10);
+        expect(await mc.scoreboard('#foreach_count', 'rs')).toBe(3);
+        expect(await mc.scoreboard('#foreach_at_count', 'rs')).toBe(3);
+    });
+});
 //# sourceMappingURL=mc-integration.test.js.map

package/dist/ast/types.d.ts

@@ -247,6 +247,45 @@ export type ExecuteSubcommand = {
 } | {
     kind: 'at';
     selector: EntitySelector;
+} | {
+    kind: 'positioned';
+    x: string;
+    y: string;
+    z: string;
+} | {
+    kind: 'positioned_as';
+    selector: EntitySelector;
+} | {
+    kind: 'rotated';
+    yaw: string;
+    pitch: string;
+} | {
+    kind: 'rotated_as';
+    selector: EntitySelector;
+} | {
+    kind: 'facing';
+    x: string;
+    y: string;
+    z: string;
+} | {
+    kind: 'facing_entity';
+    selector: EntitySelector;
+    anchor: 'eyes' | 'feet';
+} | {
+    kind: 'anchored';
+    anchor: 'eyes' | 'feet';
+} | {
+    kind: 'align';
+    axes: string;
+} | {
+    kind: 'in';
+    dimension: string;
+} | {
+    kind: 'on';
+    relation: string;
+} | {
+    kind: 'summon';
+    entity: string;
 } | {
     kind: 'if_entity';
     selector?: EntitySelector;
@@ -258,8 +297,45 @@ export type ExecuteSubcommand = {
     varName?: string;
     filters?: SelectorFilter;
 } | {
-    kind: 'in';
-    dimension: string;
+    kind: 'if_block';
+    pos: [string, string, string];
+    block: string;
+} | {
+    kind: 'unless_block';
+    pos: [string, string, string];
+    block: string;
+} | {
+    kind: 'if_score';
+    target: string;
+    targetObj: string;
+    op: string;
+    source: string;
+    sourceObj: string;
+} | {
+    kind: 'unless_score';
+    target: string;
+    targetObj: string;
+    op: string;
+    source: string;
+    sourceObj: string;
+} | {
+    kind: 'if_score_range';
+    target: string;
+    targetObj: string;
+    range: string;
+} | {
+    kind: 'unless_score_range';
+    target: string;
+    targetObj: string;
+    range: string;
+} | {
+    kind: 'store_result';
+    target: string;
+    targetObj: string;
+} | {
+    kind: 'store_success';
+    target: string;
+    targetObj: string;
 };
 export type Stmt = {
     kind: 'let';

package/dist/index.d.ts

@@ -3,7 +3,7 @@
  *
  * Main entry point for programmatic usage.
  */
-export declare const version = "1.2.10";
+export declare const version = "1.2.11";
 import type { Warning } from './lowering';
 import { DatapackFile } from './codegen/mcfunction';
 import type { IRModule } from './ir/types';

package/dist/index.js

@@ -9,7 +9,7 @@ exports.MCCommandValidator = exports.generateDatapack = exports.optimize = expor
 exports.compile = compile;
 exports.check = check;
 // eslint-disable-next-line @typescript-eslint/no-var-requires
-exports.version = '1.2.10';
+exports.version = '1.2.11';
 const lexer_1 = require("./lexer");
 const parser_1 = require("./parser");
 const typechecker_1 = require("./typechecker");

package/dist/lowering/index.d.ts

@@ -38,6 +38,7 @@ export declare class Lowering {
     private currentContext;
     private blockPosVars;
     private structDefs;
+    private structDecls;
     private enumDefs;
     private functionDefaults;
     private constValues;

package/dist/lowering/index.js

@@ -126,20 +126,20 @@ function getSpan(node) {
 const NAMESPACED_ENTITY_TYPE_RE = /^[a-z0-9_.-]+:[a-z0-9_./-]+$/;
 const BARE_ENTITY_TYPE_RE = /^[a-z0-9_./-]+$/;
 const ENTITY_TO_MC_TYPE = {
-    Player: 'player',
-    Zombie: 'zombie',
-    Skeleton: 'skeleton',
-    Creeper: 'creeper',
-    Spider: 'spider',
-    Enderman: 'enderman',
-    Pig: 'pig',
-    Cow: 'cow',
-    Sheep: 'sheep',
-    Chicken: 'chicken',
-    Villager: 'villager',
-    ArmorStand: 'armor_stand',
-    Item: 'item',
-    Arrow: 'arrow',
+    Player: 'minecraft:player',
+    Zombie: 'minecraft:zombie',
+    Skeleton: 'minecraft:skeleton',
+    Creeper: 'minecraft:creeper',
+    Spider: 'minecraft:spider',
+    Enderman: 'minecraft:enderman',
+    Pig: 'minecraft:pig',
+    Cow: 'minecraft:cow',
+    Sheep: 'minecraft:sheep',
+    Chicken: 'minecraft:chicken',
+    Villager: 'minecraft:villager',
+    ArmorStand: 'minecraft:armor_stand',
+    Item: 'minecraft:item',
+    Arrow: 'minecraft:arrow',
 };
 function normalizeSelector(selector, warnings) {
     return selector.replace(/type=([^,\]]+)/g, (match, entityType) => {
@@ -199,6 +199,8 @@ class Lowering {
         this.blockPosVars = new Map();
         // Struct definitions: name → { fieldName: TypeNode }
         this.structDefs = new Map();
+        // Full struct declarations for field iteration
+        this.structDecls = new Map();
         this.enumDefs = new Map();
         this.functionDefaults = new Map();
         this.constValues = new Map();
@@ -224,6 +226,7 @@ class Lowering {
                 fields.set(field.name, field.type);
             }
             this.structDefs.set(struct.name, fields);
+            this.structDecls.set(struct.name, struct);
         }
         for (const enumDecl of program.enums ?? []) {
             const variants = new Map();
@@ -551,6 +554,22 @@ class Lowering {
             }
             return;
         }
+        // Handle struct initialization from function call (copy from __ret_struct)
+        if ((stmt.init.kind === 'call' || stmt.init.kind === 'static_call') && stmt.type?.kind === 'struct') {
+            // First, execute the function call
+            this.lowerExpr(stmt.init);
+            // Then copy all fields from __ret_struct to the variable's storage
+            const structDecl = this.structDecls.get(stmt.type.name);
+            if (structDecl) {
+                const structName = stmt.type.name.toLowerCase();
+                for (const field of structDecl.fields) {
+                    const srcPath = `rs:heap __ret_struct.${field.name}`;
+                    const dstPath = `rs:heap ${structName}_${stmt.name}.${field.name}`;
+                    this.builder.emitRaw(`data modify storage ${dstPath} set from storage ${srcPath}`);
+                }
+            }
+            return;
+        }
         // Handle array literal initialization
         if (stmt.init.kind === 'array_lit') {
             // Initialize empty NBT array
@@ -600,6 +619,21 @@ class Lowering {
     }
     lowerReturnStmt(stmt) {
         if (stmt.value) {
+            // Handle struct literal return: store fields to __ret_struct storage
+            if (stmt.value.kind === 'struct_lit') {
+                for (const field of stmt.value.fields) {
+                    const path = `rs:heap __ret_struct.${field.name}`;
+                    const fieldValue = this.lowerExpr(field.value);
+                    if (fieldValue.kind === 'const') {
+                        this.builder.emitRaw(`data modify storage ${path} set value ${fieldValue.value}`);
+                    }
+                    else if (fieldValue.kind === 'var') {
+                        this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${fieldValue.name} rs`);
+                    }
+                }
+                this.builder.emitReturn({ kind: 'const', value: 0 });
+                return;
+            }
             const value = this.lowerExpr(stmt.value);
             this.builder.emitReturn(value);
         }
@@ -1006,18 +1040,52 @@ class Lowering {
         const parts = ['execute'];
         for (const sub of stmt.subcommands) {
             switch (sub.kind) {
+                // Context modifiers
                 case 'as':
                     parts.push(`as ${this.selectorToString(sub.selector)}`);
                     break;
                 case 'at':
                     parts.push(`at ${this.selectorToString(sub.selector)}`);
                     break;
+                case 'positioned':
+                    parts.push(`positioned ${sub.x} ${sub.y} ${sub.z}`);
+                    break;
+                case 'positioned_as':
+                    parts.push(`positioned as ${this.selectorToString(sub.selector)}`);
+                    break;
+                case 'rotated':
+                    parts.push(`rotated ${sub.yaw} ${sub.pitch}`);
+                    break;
+                case 'rotated_as':
+                    parts.push(`rotated as ${this.selectorToString(sub.selector)}`);
+                    break;
+                case 'facing':
+                    parts.push(`facing ${sub.x} ${sub.y} ${sub.z}`);
+                    break;
+                case 'facing_entity':
+                    parts.push(`facing entity ${this.selectorToString(sub.selector)} ${sub.anchor}`);
+                    break;
+                case 'anchored':
+                    parts.push(`anchored ${sub.anchor}`);
+                    break;
+                case 'align':
+                    parts.push(`align ${sub.axes}`);
+                    break;
+                case 'in':
+                    parts.push(`in ${sub.dimension}`);
+                    break;
+                case 'on':
+                    parts.push(`on ${sub.relation}`);
+                    break;
+                case 'summon':
+                    parts.push(`summon ${sub.entity}`);
+                    break;
+                // Conditions
                 case 'if_entity':
                     if (sub.selector) {
                         parts.push(`if entity ${this.selectorToString(sub.selector)}`);
                     }
                     else if (sub.varName) {
-                        // Variable with filters - substitute with @s and apply filters
                         const sel = { kind: '@s', filters: sub.filters };
                         parts.push(`if entity ${this.selectorToString(sel)}`);
                     }
@@ -1027,13 +1095,34 @@ class Lowering {
                         parts.push(`unless entity ${this.selectorToString(sub.selector)}`);
                     }
                     else if (sub.varName) {
-                        // Variable with filters - substitute with @s and apply filters
                         const sel = { kind: '@s', filters: sub.filters };
                         parts.push(`unless entity ${this.selectorToString(sel)}`);
                     }
                     break;
-                case 'in':
-                    parts.push(`in ${sub.dimension}`);
+                case 'if_block':
+                    parts.push(`if block ${sub.pos[0]} ${sub.pos[1]} ${sub.pos[2]} ${sub.block}`);
+                    break;
+                case 'unless_block':
+                    parts.push(`unless block ${sub.pos[0]} ${sub.pos[1]} ${sub.pos[2]} ${sub.block}`);
+                    break;
+                case 'if_score':
+                    parts.push(`if score ${sub.target} ${sub.targetObj} ${sub.op} ${sub.source} ${sub.sourceObj}`);
+                    break;
+                case 'unless_score':
+                    parts.push(`unless score ${sub.target} ${sub.targetObj} ${sub.op} ${sub.source} ${sub.sourceObj}`);
+                    break;
+                case 'if_score_range':
+                    parts.push(`if score ${sub.target} ${sub.targetObj} matches ${sub.range}`);
+                    break;
+                case 'unless_score_range':
+                    parts.push(`unless score ${sub.target} ${sub.targetObj} matches ${sub.range}`);
+                    break;
+                // Store
+                case 'store_result':
+                    parts.push(`store result score ${sub.target} ${sub.targetObj}`);
+                    break;
+                case 'store_success':
+                    parts.push(`store success score ${sub.target} ${sub.targetObj}`);
                     break;
             }
         }
@@ -1451,6 +1540,22 @@ class Lowering {
         }
         const implMethod = this.resolveInstanceMethod(expr);
         if (implMethod) {
+            // Copy struct fields from instance to 'self' storage before calling
+            const receiver = expr.args[0];
+            if (receiver?.kind === 'ident') {
+                const receiverType = this.inferExprType(receiver);
+                if (receiverType?.kind === 'struct') {
+                    const structDecl = this.structDecls.get(receiverType.name);
+                    const structName = receiverType.name.toLowerCase();
+                    if (structDecl) {
+                        for (const field of structDecl.fields) {
+                            const srcPath = `rs:heap ${structName}_${receiver.name}.${field.name}`;
+                            const dstPath = `rs:heap ${structName}_self.${field.name}`;
+                            this.builder.emitRaw(`data modify storage ${dstPath} set from storage ${srcPath}`);
+                        }
+                    }
+                }
+            }
             return this.emitMethodCall(implMethod.loweredName, implMethod.fn, expr.args);
         }
         // Regular function call

package/dist/optimizer/dce.js

@@ -115,9 +115,12 @@ class DeadCodeEliminator {
     findEntryPoints(program) {
         const entries = new Set();
         for (const fn of program.declarations) {
-            if (fn.name === 'main') {
+            // All top-level functions are entry points (callable via /function)
+            // Exception: functions starting with _ are considered private/internal
+            if (!fn.name.startsWith('_')) {
                 entries.add(fn.name);
             }
+            // Decorated functions are always entry points (even if prefixed with _)
             if (fn.decorators.some(decorator => [
                 'tick',
                 'load',
@@ -128,7 +131,7 @@ class DeadCodeEliminator {
                 'on_death',
                 'on_login',
                 'on_join_team',
-                'keep', // Prevent DCE from removing this function
+                'keep',
             ].includes(decorator.name))) {
                 entries.add(fn.name);
             }

package/dist/parser/index.d.ts

@@ -45,6 +45,10 @@ export declare class Parser {
     private parseAsStmt;
     private parseAtStmt;
     private parseExecuteStmt;
+    private parseExecuteCondition;
+    private parseCoordToken;
+    private parseBlockId;
+    private checkIdent;
     private parseExprStmt;
     private parseExpr;
     private parseAssignment;