redscript-mc 3.0.0 → 3.0.2

package/dist/src/lir/types.d.ts

@@ -131,6 +131,8 @@ export interface LIRFunction {
     instructions: LIRInstr[];
     isMacro: boolean;
     macroParams: string[];
+    params?: string[];
+    returnType?: string;
     sourceLoc?: SourceLoc;
     sourceSnippet?: string;
 }

package/dist/src/lsp/rename.d.ts

@@ -0,0 +1,5 @@
+import type { WorkspaceEdit, Position, Range } from 'vscode-languageserver/node';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import type { Program } from '../ast/types';
+export declare function findRenameRanges(source: string, program: Program, position: Position): Range[];
+export declare function buildRenameWorkspaceEdit(doc: TextDocument, program: Program, position: Position, newName: string): WorkspaceEdit | null;

package/dist/src/lsp/rename.js

@@ -0,0 +1,502 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRenameRanges = findRenameRanges;
+exports.buildRenameWorkspaceEdit = buildRenameWorkspaceEdit;
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const lexer_1 = require("../lexer");
+function keyFor(line, col) {
+    return `${line}:${col}`;
+}
+function buildTokenCursor(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize().filter(token => token.kind !== 'eof');
+    const byLineCol = new Map();
+    tokens.forEach((token, index) => byLineCol.set(keyFor(token.line, token.col), index));
+    return { tokens, byLineCol };
+}
+function tokenToRange(doc, token) {
+    const start = doc.positionAt(doc.offsetAt({ line: token.line - 1, character: token.col - 1 }));
+    const end = doc.positionAt(doc.offsetAt({ line: token.line - 1, character: token.col - 1 }) + token.value.length);
+    return { start, end };
+}
+function containsPosition(token, position) {
+    const line = token.line - 1;
+    const start = token.col - 1;
+    const end = start + token.value.length;
+    return position.line === line && position.character >= start && position.character <= end;
+}
+function makeScope(parent) {
+    return {
+        parent,
+        locals: new Map(),
+        types: new Map(),
+    };
+}
+function resolveLocal(scope, name) {
+    let cur = scope;
+    while (cur) {
+        const found = cur.locals.get(name);
+        if (found)
+            return found;
+        cur = cur.parent;
+    }
+    return null;
+}
+function resolveType(scope, name) {
+    let cur = scope;
+    while (cur) {
+        const found = cur.types.get(name);
+        if (found)
+            return found;
+        cur = cur.parent;
+    }
+    return null;
+}
+function findTokenIndex(cursor, line, col) {
+    return cursor.byLineCol.get(keyFor(line, col)) ?? -1;
+}
+function findNextToken(cursor, startIndex, predicate) {
+    for (let i = Math.max(0, startIndex); i < cursor.tokens.length; i++) {
+        if (predicate(cursor.tokens[i], i))
+            return cursor.tokens[i];
+    }
+    return null;
+}
+function findFunctionNameToken(cursor, fn) {
+    if (!fn.span)
+        return null;
+    const fnIndex = findTokenIndex(cursor, fn.span.line, fn.span.col);
+    if (fnIndex === -1)
+        return null;
+    return findNextToken(cursor, fnIndex + 1, token => token.kind === 'ident' && token.value === fn.name);
+}
+function findDeclarationNameToken(cursor, stmt) {
+    if (!stmt.span)
+        return null;
+    const startIndex = findTokenIndex(cursor, stmt.span.line, stmt.span.col);
+    if (startIndex === -1)
+        return null;
+    return findNextToken(cursor, startIndex + 1, token => token.kind === 'ident' && token.value === stmt.name && token.line === stmt.span.line);
+}
+function findFieldDeclarationTokens(cursor, program) {
+    const result = new Map();
+    for (const struct of program.structs ?? []) {
+        if (!struct.span)
+            continue;
+        const structIndex = findTokenIndex(cursor, struct.span.line, struct.span.col);
+        if (structIndex === -1)
+            continue;
+        let i = structIndex;
+        while (i < cursor.tokens.length && cursor.tokens[i].kind !== '{')
+            i++;
+        if (i >= cursor.tokens.length)
+            continue;
+        let fieldIndex = 0;
+        let depth = 1;
+        i++;
+        while (i < cursor.tokens.length && depth > 0 && fieldIndex < struct.fields.length) {
+            const token = cursor.tokens[i];
+            if (token.kind === '{')
+                depth++;
+            else if (token.kind === '}')
+                depth--;
+            else if (depth === 1 &&
+                token.kind === 'ident' &&
+                token.value === struct.fields[fieldIndex].name &&
+                cursor.tokens[i + 1]?.kind === ':') {
+                result.set(`${struct.name}.${token.value}`, token);
+                fieldIndex++;
+            }
+            i++;
+        }
+    }
+    return result;
+}
+function findParamToken(cursor, fn, paramName, fromIndex) {
+    return findNextToken(cursor, fromIndex, token => token.kind === 'ident' && token.value === paramName && cursor.tokens[cursor.tokens.indexOf(token) + 1]?.kind === ':');
+}
+function findFieldAccessToken(cursor, expr) {
+    if (!expr.span)
+        return null;
+    const startIndex = findTokenIndex(cursor, expr.span.line, expr.span.col);
+    if (startIndex === -1)
+        return null;
+    return findNextToken(cursor, startIndex + 1, (token, index) => token.kind === 'ident' && token.value === expr.field && cursor.tokens[index - 1]?.kind === '.' && token.line === expr.span.line);
+}
+function findStructLiteralFieldToken(cursor, expr, fieldName, skipCount) {
+    if (!expr.span)
+        return null;
+    const startIndex = findTokenIndex(cursor, expr.span.line, expr.span.col);
+    if (startIndex === -1)
+        return null;
+    let depth = 0;
+    let skipped = 0;
+    for (let i = startIndex; i < cursor.tokens.length; i++) {
+        const token = cursor.tokens[i];
+        if (token.kind === '{')
+            depth++;
+        else if (token.kind === '}') {
+            depth--;
+            if (depth === 0)
+                break;
+        }
+        else if (depth === 1 &&
+            token.kind === 'ident' &&
+            token.value === fieldName &&
+            cursor.tokens[i + 1]?.kind === ':') {
+            if (skipped === skipCount)
+                return token;
+            skipped++;
+        }
+    }
+    return null;
+}
+function typeNameOf(type, program) {
+    if (!type)
+        return null;
+    if (type.kind === 'struct')
+        return type.name;
+    if (type.kind === 'named' && program.structs?.some(struct => struct.name === type.name))
+        return type.name;
+    return null;
+}
+function resolveExprStructName(expr, scope, program, currentFn) {
+    switch (expr.kind) {
+        case 'ident':
+            return typeNameOf(resolveType(scope, expr.name), program);
+        case 'member': {
+            const objType = resolveExprStructName(expr.obj, scope, program, currentFn);
+            if (!objType)
+                return null;
+            const structDecl = program.structs?.find(struct => struct.name === objType);
+            const fieldType = structDecl?.fields.find(field => field.name === expr.field)?.type;
+            return typeNameOf(fieldType, program);
+        }
+        case 'call': {
+            const fn = program.declarations.find(candidate => candidate.name === expr.fn);
+            return typeNameOf(fn?.returnType, program);
+        }
+        case 'type_cast':
+            return typeNameOf(expr.targetType, program);
+        case 'struct_lit':
+            return typeNameOf(currentFn.returnType, program);
+        default:
+            return null;
+    }
+}
+function addOccurrence(symbol, token) {
+    if (!symbol || !token)
+        return;
+    if (symbol.occurrences.some(existing => existing.line === token.line && existing.col === token.col))
+        return;
+    symbol.occurrences.push(token);
+}
+function buildRenameIndex(source, program) {
+    const cursor = buildTokenCursor(source);
+    const symbols = [];
+    const functions = new Map();
+    const fieldSymbols = new Map();
+    const fieldDeclTokens = findFieldDeclarationTokens(cursor, program);
+    for (const fn of program.declarations) {
+        const symbol = { kind: 'function', name: fn.name, occurrences: [] };
+        addOccurrence(symbol, findFunctionNameToken(cursor, fn));
+        functions.set(fn.name, symbol);
+        symbols.push(symbol);
+    }
+    for (const struct of program.structs ?? []) {
+        for (const field of struct.fields) {
+            const symbol = {
+                kind: 'field',
+                name: field.name,
+                structName: struct.name,
+                occurrences: [],
+            };
+            addOccurrence(symbol, fieldDeclTokens.get(`${struct.name}.${field.name}`) ?? null);
+            fieldSymbols.set(`${struct.name}.${field.name}`, symbol);
+            symbols.push(symbol);
+        }
+    }
+    function walkBlock(block, scope, currentFn) {
+        for (const stmt of block)
+            walkStmt(stmt, scope, currentFn);
+    }
+    function bindLocal(name, type, token, scope) {
+        const symbol = { kind: 'local', name, occurrences: [] };
+        addOccurrence(symbol, token);
+        scope.locals.set(name, symbol);
+        if (type)
+            scope.types.set(name, type);
+        symbols.push(symbol);
+        return symbol;
+    }
+    function walkPattern(pattern, scope, currentFn) {
+        if (pattern.kind === 'PatSome') {
+            bindLocal(pattern.binding, undefined, null, scope);
+        }
+        else if (pattern.kind === 'PatEnum') {
+            for (const binding of pattern.bindings)
+                bindLocal(binding, undefined, null, scope);
+        }
+        else if (pattern.kind === 'PatExpr') {
+            walkExpr(pattern.expr, scope, null, currentFn);
+        }
+    }
+    function walkStmt(stmt, scope, currentFn) {
+        switch (stmt.kind) {
+            case 'let': {
+                walkExpr(stmt.init, scope, stmt.type ? typeNameOf(stmt.type, program) : null, currentFn);
+                const inferredType = stmt.type ?? (() => {
+                    const inferredStruct = resolveExprStructName(stmt.init, scope, program, currentFn);
+                    return inferredStruct ? { kind: 'struct', name: inferredStruct } : undefined;
+                })();
+                bindLocal(stmt.name, inferredType, findDeclarationNameToken(cursor, stmt), scope);
+                return;
+            }
+            case 'const_decl':
+                walkExpr(stmt.value, scope, null, currentFn);
+                bindLocal(stmt.name, stmt.type, findDeclarationNameToken(cursor, stmt), scope);
+                return;
+            case 'let_destruct':
+                walkExpr(stmt.init, scope, null, currentFn);
+                for (const name of stmt.names)
+                    bindLocal(name, stmt.type, null, scope);
+                return;
+            case 'expr':
+                walkExpr(stmt.expr, scope, null, currentFn);
+                return;
+            case 'return':
+                if (stmt.value)
+                    walkExpr(stmt.value, scope, typeNameOf(currentFn.returnType, program), currentFn);
+                return;
+            case 'if':
+                walkExpr(stmt.cond, scope, null, currentFn);
+                walkBlock(stmt.then, makeScope(scope), currentFn);
+                if (stmt.else_)
+                    walkBlock(stmt.else_, makeScope(scope), currentFn);
+                return;
+            case 'while':
+            case 'do_while':
+                walkExpr(stmt.cond, scope, null, currentFn);
+                walkBlock(stmt.body, makeScope(scope), currentFn);
+                return;
+            case 'repeat':
+            case 'as_block':
+            case 'at_block':
+            case 'as_at':
+            case 'execute':
+                walkBlock(stmt.body, makeScope(scope), currentFn);
+                return;
+            case 'for': {
+                const forScope = makeScope(scope);
+                if (stmt.init)
+                    walkStmt(stmt.init, forScope, currentFn);
+                walkExpr(stmt.cond, forScope, null, currentFn);
+                walkExpr(stmt.step, forScope, null, currentFn);
+                walkBlock(stmt.body, forScope, currentFn);
+                return;
+            }
+            case 'foreach': {
+                walkExpr(stmt.iterable, scope, null, currentFn);
+                const foreachScope = makeScope(scope);
+                bindLocal(stmt.binding, undefined, null, foreachScope);
+                walkBlock(stmt.body, foreachScope, currentFn);
+                return;
+            }
+            case 'for_range': {
+                walkExpr(stmt.start, scope, null, currentFn);
+                walkExpr(stmt.end, scope, null, currentFn);
+                const forScope = makeScope(scope);
+                bindLocal(stmt.varName, { kind: 'named', name: 'int' }, null, forScope);
+                walkBlock(stmt.body, forScope, currentFn);
+                return;
+            }
+            case 'for_each': {
+                walkExpr(stmt.array, scope, null, currentFn);
+                const forScope = makeScope(scope);
+                bindLocal(stmt.binding, undefined, null, forScope);
+                walkBlock(stmt.body, forScope, currentFn);
+                return;
+            }
+            case 'for_in_array': {
+                const forScope = makeScope(scope);
+                bindLocal(stmt.binding, undefined, null, forScope);
+                walkExpr(stmt.lenExpr, forScope, null, currentFn);
+                walkBlock(stmt.body, forScope, currentFn);
+                return;
+            }
+            case 'match':
+                walkExpr(stmt.expr, scope, null, currentFn);
+                for (const arm of stmt.arms) {
+                    const armScope = makeScope(scope);
+                    walkPattern(arm.pattern, armScope, currentFn);
+                    walkBlock(arm.body, armScope, currentFn);
+                }
+                return;
+            case 'if_let_some': {
+                walkExpr(stmt.init, scope, null, currentFn);
+                const thenScope = makeScope(scope);
+                bindLocal(stmt.binding, undefined, null, thenScope);
+                walkBlock(stmt.then, thenScope, currentFn);
+                if (stmt.else_)
+                    walkBlock(stmt.else_, makeScope(scope), currentFn);
+                return;
+            }
+            case 'while_let_some': {
+                walkExpr(stmt.init, scope, null, currentFn);
+                const whileScope = makeScope(scope);
+                bindLocal(stmt.binding, undefined, null, whileScope);
+                walkBlock(stmt.body, whileScope, currentFn);
+                return;
+            }
+            case 'labeled_loop':
+                walkStmt(stmt.body, makeScope(scope), currentFn);
+                return;
+            default:
+                return;
+        }
+    }
+    function walkExpr(expr, scope, expectedStructName, currentFn) {
+        switch (expr.kind) {
+            case 'ident':
+                addOccurrence(resolveLocal(scope, expr.name), expr.span ? cursor.tokens[findTokenIndex(cursor, expr.span.line, expr.span.col)] ?? null : null);
+                return;
+            case 'assign':
+                addOccurrence(resolveLocal(scope, expr.target), expr.span ? cursor.tokens[findTokenIndex(cursor, expr.span.line, expr.span.col)] ?? null : null);
+                walkExpr(expr.value, scope, null, currentFn);
+                return;
+            case 'call':
+                addOccurrence(functions.get(expr.fn) ?? null, expr.span ? cursor.tokens[findTokenIndex(cursor, expr.span.line, expr.span.col)] ?? null : null);
+                for (const arg of expr.args)
+                    walkExpr(arg, scope, null, currentFn);
+                return;
+            case 'member': {
+                walkExpr(expr.obj, scope, null, currentFn);
+                const structName = resolveExprStructName(expr.obj, scope, program, currentFn);
+                addOccurrence(structName ? fieldSymbols.get(`${structName}.${expr.field}`) ?? null : null, findFieldAccessToken(cursor, expr));
+                return;
+            }
+            case 'member_assign': {
+                walkExpr(expr.obj, scope, null, currentFn);
+                const structName = resolveExprStructName(expr.obj, scope, program, currentFn);
+                addOccurrence(structName ? fieldSymbols.get(`${structName}.${expr.field}`) ?? null : null, findFieldAccessToken(cursor, expr));
+                walkExpr(expr.value, scope, structName ? typeNameOf(program.structs?.find(struct => struct.name === structName)?.fields.find(field => field.name === expr.field)?.type, program) : null, currentFn);
+                return;
+            }
+            case 'struct_lit': {
+                const structName = expectedStructName;
+                if (structName) {
+                    expr.fields.forEach((field, index) => {
+                        addOccurrence(fieldSymbols.get(`${structName}.${field.name}`) ?? null, findStructLiteralFieldToken(cursor, expr, field.name, index));
+                        const fieldType = program.structs?.find(struct => struct.name === structName)?.fields.find(candidate => candidate.name === field.name)?.type;
+                        walkExpr(field.value, scope, typeNameOf(fieldType, program), currentFn);
+                    });
+                }
+                else {
+                    for (const field of expr.fields)
+                        walkExpr(field.value, scope, null, currentFn);
+                }
+                return;
+            }
+            case 'binary':
+                walkExpr(expr.left, scope, null, currentFn);
+                walkExpr(expr.right, scope, null, currentFn);
+                return;
+            case 'unary':
+            case 'type_cast':
+                walkExpr(expr.kind === 'unary' ? expr.operand : expr.expr, scope, null, currentFn);
+                return;
+            case 'invoke':
+                walkExpr(expr.callee, scope, null, currentFn);
+                for (const arg of expr.args)
+                    walkExpr(arg, scope, null, currentFn);
+                return;
+            case 'index':
+                walkExpr(expr.obj, scope, null, currentFn);
+                walkExpr(expr.index, scope, null, currentFn);
+                return;
+            case 'index_assign':
+                walkExpr(expr.obj, scope, null, currentFn);
+                walkExpr(expr.index, scope, null, currentFn);
+                walkExpr(expr.value, scope, null, currentFn);
+                return;
+            case 'array_lit':
+            case 'tuple_lit':
+                for (const item of expr.elements)
+                    walkExpr(item, scope, null, currentFn);
+                return;
+            case 'enum_construct':
+                for (const arg of expr.args)
+                    walkExpr(arg.value, scope, null, currentFn);
+                return;
+            case 'some_lit':
+                walkExpr(expr.value, scope, null, currentFn);
+                return;
+            case 'unwrap_or':
+                walkExpr(expr.opt, scope, null, currentFn);
+                walkExpr(expr.default_, scope, null, currentFn);
+                return;
+            case 'str_interp':
+                for (const part of expr.parts) {
+                    if (typeof part !== 'string')
+                        walkExpr(part, scope, null, currentFn);
+                }
+                return;
+            case 'f_string':
+                for (const part of expr.parts) {
+                    if (part.kind === 'expr')
+                        walkExpr(part.expr, scope, null, currentFn);
+                }
+                return;
+            case 'lambda': {
+                const lambdaScope = makeScope(scope);
+                let fromIndex = expr.span ? findTokenIndex(cursor, expr.span.line, expr.span.col) : -1;
+                for (const param of expr.params) {
+                    const token = findParamToken(cursor, currentFn, param.name, fromIndex + 1);
+                    if (token)
+                        fromIndex = cursor.tokens.indexOf(token);
+                    bindLocal(param.name, param.type, token, lambdaScope);
+                }
+                if (Array.isArray(expr.body))
+                    walkBlock(expr.body, lambdaScope, currentFn);
+                else
+                    walkExpr(expr.body, lambdaScope, null, currentFn);
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    for (const fn of program.declarations) {
+        const rootScope = makeScope(null);
+        let fromIndex = (findFunctionNameToken(cursor, fn) && cursor.tokens.indexOf(findFunctionNameToken(cursor, fn))) || -1;
+        for (const param of fn.params) {
+            const token = findParamToken(cursor, fn, param.name, fromIndex + 1);
+            if (token)
+                fromIndex = cursor.tokens.indexOf(token);
+            bindLocal(param.name, param.type, token, rootScope);
+        }
+        walkBlock(fn.body, rootScope, fn);
+    }
+    return symbols;
+}
+function findRenameRanges(source, program, position) {
+    const doc = vscode_languageserver_textdocument_1.TextDocument.create('file:///rename.mcrs', 'redscript', 1, source);
+    const symbols = buildRenameIndex(source, program);
+    const symbol = symbols.find(candidate => candidate.occurrences.some(token => containsPosition(token, position)));
+    if (!symbol)
+        return [];
+    return symbol.occurrences
+        .slice()
+        .sort((a, b) => (a.line - b.line) || (a.col - b.col))
+        .map(token => tokenToRange(doc, token));
+}
+function buildRenameWorkspaceEdit(doc, program, position, newName) {
+    const ranges = findRenameRanges(doc.getText(), program, position);
+    if (ranges.length === 0)
+        return null;
+    return {
+        changes: {
+            [doc.uri]: ranges.map(range => ({ range, newText: newName })),
+        },
+    };
+}
+//# sourceMappingURL=rename.js.map

package/dist/src/lsp/server.js

@@ -54,6 +54,7 @@ const typechecker_1 = require("../typechecker");
 const diagnostics_1 = require("../diagnostics");
 const metadata_1 = require("../builtins/metadata");
 const lint_1 = require("../lint");
+const rename_1 = require("./rename");
 // ---------------------------------------------------------------------------
 // Connection and document manager
 // ---------------------------------------------------------------------------
@@ -1321,22 +1322,10 @@ connection.onRenameRequest((params) => {
     const doc = documents.get(params.textDocument.uri);
     if (!doc)
         return null;
-    const wordRange = getWordRangeAtPosition(doc, params.position);
-    if (!wordRange)
-        return null;
-    const word = doc.getText(wordRange);
-    if (!word)
+    const parsed = parsedDocs.get(params.textDocument.uri);
+    if (!parsed?.program)
         return null;
-    const text = doc.getText();
-    const edits = [];
-    const regex = new RegExp(`\\b${word}\\b`, 'g');
-    let match;
-    while ((match = regex.exec(text)) !== null) {
-        const start = doc.positionAt(match.index);
-        const end = doc.positionAt(match.index + word.length);
-        edits.push({ range: { start, end }, newText: params.newName });
-    }
-    return { changes: { [params.textDocument.uri]: edits } };
+    return (0, rename_1.buildRenameWorkspaceEdit)(doc, parsed.program, params.position, params.newName);
 });
 // ---------------------------------------------------------------------------
 // Start

package/dist/src/mc-test/client.d.ts

@@ -133,6 +133,27 @@ export declare class MCTestClient {
      * Assert chat log contains a message matching substring.
      */
     assertChatContains(substring: string, since?: number): Promise<void>;
+    /**
+     * Dump all scoreboard entries for a namespace's objective (__<ns>).
+     * Returns { "$p0": 0, "$val": 11, "#result": 42, ... }
+     */
+    dumpScores(ns: string): Promise<Record<string, number>>;
+    /**
+     * Dump all scoreboard entries for a specific objective.
+     */
+    dumpScoresByObj(obj: string): Promise<Record<string, number>>;
+    /**
+     * Dump the raw NBT of an entire storage namespace.
+     */
+    dumpStorage(storage: string): Promise<{
+        raw: string;
+        ok: boolean;
+    }>;
+    /**
+     * Assert multiple scoreboard values at once.
+     * Usage: await mc.assertScoreMap('ns', { '$p0': 11, '$ret': 2 })
+     */
+    assertScoreMap(ns: string, expected: Record<string, number>): Promise<void>;
     /**
      * Wait until a scoreboard value equals expected, up to timeout ms.
      */

package/dist/src/mc-test/client.js

@@ -180,6 +180,40 @@ class MCTestClient {
             throw new Error(`assertChatContains: "${substring}" not found in chat. Recent: [${recent}]`);
         }
     }
+    /**
+     * Dump all scoreboard entries for a namespace's objective (__<ns>).
+     * Returns { "$p0": 0, "$val": 11, "#result": 42, ... }
+     */
+    async dumpScores(ns) {
+        return this.get('/scoreboard/dump', { ns })
+            .then((r) => r.entries ?? {});
+    }
+    /**
+     * Dump all scoreboard entries for a specific objective.
+     */
+    async dumpScoresByObj(obj) {
+        return this.get('/scoreboard/dump', { obj })
+            .then((r) => r.entries ?? {});
+    }
+    /**
+     * Dump the raw NBT of an entire storage namespace.
+     */
+    async dumpStorage(storage) {
+        return this.get('/storage/dump', { storage });
+    }
+    /**
+     * Assert multiple scoreboard values at once.
+     * Usage: await mc.assertScoreMap('ns', { '$p0': 11, '$ret': 2 })
+     */
+    async assertScoreMap(ns, expected) {
+        const actual = await this.dumpScores(ns);
+        for (const [key, val] of Object.entries(expected)) {
+            if (actual[key] !== val) {
+                throw new Error(`assertScoreMap[${ns}] ${key}: expected ${val}, got ${actual[key] ?? '(unset)'}\n` +
+                    `Full dump: ${JSON.stringify(actual)}`);
+            }
+        }
+    }
     /**
      * Wait until a scoreboard value equals expected, up to timeout ms.
      */