cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/go/interpret.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpretGoImport = interpretGoImport;
+exports.interpretGoTypeBinding = interpretGoTypeBinding;
+exports.goMapValueType = goMapValueType;
+exports.normalizeGoTypeName = normalizeGoTypeName;
+exports.normalizeGoReturnType = normalizeGoReturnType;
+function interpretGoImport(captures) {
+    const kind = captures['@import.kind']?.text;
+    const source = captures['@import.source']?.text;
+    const name = captures['@import.name']?.text;
+    const alias = captures['@import.alias']?.text;
+    if (kind === undefined || source === undefined)
+        return null;
+    if (kind === 'dot')
+        return { kind: 'wildcard', targetRaw: source };
+    if (kind === 'alias') {
+        if (alias === undefined || name === undefined)
+            return null;
+        return { kind: 'namespace', localName: alias, importedName: name, targetRaw: source };
+    }
+    if (kind === 'namespace') {
+        if (name === undefined)
+            return null;
+        return { kind: 'namespace', localName: name, importedName: name, targetRaw: source };
+    }
+    return null;
+}
+function interpretGoTypeBinding(captures) {
+    const name = captures['@type-binding.name']?.text;
+    const type = captures['@type-binding.type']?.text;
+    if (name === undefined || type === undefined)
+        return null;
+    let source = 'annotation';
+    let normalizedType;
+    if (captures['@type-binding.self'] !== undefined) {
+        source = 'self';
+        // Preserve pointer shape on receiver self-bindings (`*T` vs `T`).
+        // Method-owner enrichment consumes that raw shape to stamp `goReceiverKind`
+        // on each method. Since #2813 that stamp is metadata, NOT a filter:
+        // structural interface satisfaction counts pointer-receiver methods, because
+        // `*T`'s method set is what an interface-typed field actually holds. The
+        // preserved distinction is the hook a future value/pointer-aware model would
+        // read — do not reintroduce it as an exclusion.
+        normalizedType = type.trim();
+    }
+    else if (captures['@type-binding.constructor'] !== undefined) {
+        source = 'constructor-inferred';
+        normalizedType = normalizeGoTypeName(type);
+    }
+    else if (captures['@type-binding.call-return'] !== undefined) {
+        source = 'constructor-inferred';
+        normalizedType = normalizeGoTypeName(type);
+    }
+    else if (captures['@type-binding.assertion'] !== undefined) {
+        source = 'annotation';
+        normalizedType = normalizeGoTypeName(type);
+    }
+    else if (captures['@type-binding.new'] !== undefined) {
+        source = 'constructor-inferred';
+        normalizedType = normalizeGoTypeName(type);
+    }
+    else if (captures['@type-binding.field'] !== undefined) {
+        source = 'assignment-inferred';
+        normalizedType = normalizeGoTypeName(type);
+    }
+    else if (captures['@type-binding.range'] !== undefined) {
+        source = 'constructor-inferred';
+        normalizedType = normalizeGoTypeName(type);
+    }
+    else if (captures['@type-binding.index'] !== undefined) {
+        source = 'constructor-inferred';
+        normalizedType = normalizeGoTypeName(type);
+    }
+    else if (captures['@type-binding.multi-assign'] !== undefined) {
+        source = 'constructor-inferred';
+        normalizedType = normalizeGoTypeName(type);
+    }
+    else if (captures['@type-binding.make'] !== undefined) {
+        source = 'constructor-inferred';
+        normalizedType = normalizeGoTypeName(type);
+    }
+    else if (captures['@type-binding.return'] !== undefined) {
+        // Preserve dotted names for cross-package return-type chains.
+        source = 'return-annotation';
+        normalizedType = normalizeGoReturnType(type);
+    }
+    else if (captures['@type-binding.alias'] !== undefined) {
+        source = 'assignment-inferred';
+        normalizedType = normalizeGoTypeName(type);
+    }
+    else if (captures['@type-binding.assignment'] !== undefined) {
+        source = 'assignment-inferred';
+        normalizedType = normalizeGoTypeName(type);
+    }
+    else if (captures['@type-binding.parameter'] !== undefined) {
+        source = 'parameter-annotation';
+        normalizedType = normalizeGoTypeName(type);
+    }
+    else {
+        normalizedType = normalizeGoTypeName(type);
+    }
+    return { boundName: name, rawTypeName: normalizedType, source };
+}
+/** Shallow `map[K]V` spelling match — the key is anything up to the first `]`,
+ *  so a nested map key (`map[map[a]b]V`) is deliberately NOT recognised. Held
+ *  in one place so the capture-side normalizers and the resolver's element-type
+ *  hook cannot drift on what counts as a map spelling. */
+const GO_MAP_VALUE_RE = /^map\[[^\]]+\]\s*(.+)$/;
+/** `map[K]V` → `V`, trimmed. `undefined` when `text` is not a map spelling. */
+function goMapValueType(text) {
+    const match = GO_MAP_VALUE_RE.exec(text);
+    return match === null ? undefined : match[1].trim();
+}
+function normalizeGoTypeName(text) {
+    let t = text.trim();
+    t = stripGoOuterTypePrefixes(t);
+    const mapValue = goMapValueType(t);
+    if (mapValue !== undefined)
+        t = mapValue;
+    t = stripGoOuterTypePrefixes(t.replace(/^(?:<-)?chan(?:<-)?\s+/, ''));
+    if (t.startsWith('func(')) {
+        const retMatch = t.match(/^func\([^)]*\)\s*(.*)$/);
+        if (retMatch)
+            t = retMatch[1].trim();
+    }
+    const dot = t.lastIndexOf('.');
+    if (dot !== -1)
+        t = t.slice(dot + 1);
+    const bracket = t.indexOf('[');
+    if (bracket !== -1)
+        t = t.slice(0, bracket);
+    return t;
+}
+/**
+ * Like `normalizeGoTypeName` but preserves dotted package-prefix
+ * (`models.User` stays `models.User`). Used for return-type
+ * annotations so cross-package type chains can resolve through
+ * QualifiedNameIndex (which carries `pkg.Type` entries).
+ */
+function normalizeGoReturnType(text) {
+    let t = text.trim();
+    // Multi-return syntax: (*T, error) → extract first type. Handles
+    // the common Go pattern where functions return (value, error).
+    if (t.startsWith('(') && t.includes(',')) {
+        const closeIdx = t.indexOf(',');
+        t = t.slice(1, closeIdx).trim();
+    }
+    t = stripGoOuterTypePrefixes(t);
+    const mapValue = goMapValueType(t);
+    if (mapValue !== undefined)
+        t = mapValue;
+    t = stripGoOuterTypePrefixes(t.replace(/^(?:<-)?chan(?:<-)?\s+/, ''));
+    if (t.startsWith('func(')) {
+        const retMatch = t.match(/^func\([^)]*\)\s*(.*)$/);
+        if (retMatch)
+            t = retMatch[1].trim();
+    }
+    // Preserve dotted qualified names for cross-package resolution.
+    const bracket = t.indexOf('[');
+    if (bracket !== -1)
+        t = t.slice(0, bracket);
+    return t;
+}
+function stripGoOuterTypePrefixes(text) {
+    let t = text.trim();
+    let previous;
+    do {
+        previous = t;
+        while (t.startsWith('*'))
+            t = t.slice(1).trim();
+        if (t.startsWith('[]'))
+            t = t.slice(2).trim();
+        t = t.replace(/^\[[^\]]+\]\s*/, '');
+    } while (t !== previous);
+    return t;
+}

package/dist/core/code/engine/core/ingestion/languages/go/merge-bindings.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goMergeBindings = goMergeBindings;
+const TIER = {
+    local: 0,
+    namespace: 1,
+    import: 2,
+    reexport: 3,
+    wildcard: 4,
+};
+function goMergeBindings(existing, incoming, _scopeId) {
+    const seen = new Set();
+    return [...existing, ...incoming]
+        .sort((a, b) => (TIER[a.origin] ?? 99) - (TIER[b.origin] ?? 99) || a.def.nodeId.localeCompare(b.def.nodeId))
+        .filter((binding) => {
+        if (seen.has(binding.def.nodeId))
+            return false;
+        seen.add(binding.def.nodeId);
+        return true;
+    });
+}

package/dist/core/code/engine/core/ingestion/languages/go/method-owners.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.populateGoOwners = populateGoOwners;
+exports.populateGoWorkspaceOwners = populateGoWorkspaceOwners;
+const logger_js_1 = require("../../../logger.js");
+const walkers_js_1 = require("../../scope-resolution/scope/walkers.js");
+const package_clause_js_1 = require("./package-clause.js");
+const generic_type_parameters_js_1 = require("./generic-type-parameters.js");
+/** Bound on the sample of no-package-clause paths named in the warning. */
+const SKIPPED_SAMPLE_CAP = 5;
+/**
+ * Populate `ownerId` on Go Method defs by matching receiver types
+ * extracted from `@type-binding.self` captures against struct defs in
+ * the module scope.
+ *
+ * Go method declarations are top-level (`func (r *T) M()`), not nested
+ * inside a struct body. The generic `populateClassOwnedMembers` requires
+ * the method's parent scope to be a `Class` scope, which never matches
+ * Go. This pass bridges the gap by reading the self typeBinding that
+ * `synthesizeGoReceiverBinding` creates, locating the matching struct
+ * def, and stamping `ownerId` onto the Method def.
+ */
+function populateGoOwners(parsed) {
+    // 1. Standard nested-class pass — stamps ownerId on Property/Method defs
+    //    inside Class scopes. With Class scopes now created for Go
+    //    struct/interface declarations, this handles struct field ownership.
+    (0, walkers_js_1.populateClassOwnedMembers)(parsed);
+    populateGoOwnersInPackage([parsed]);
+}
+function populateGoWorkspaceOwners(parsedFiles, ctx) {
+    // Generic interfaces get their type-parameter list stamped here rather than at
+    // capture time, because this is the first main-thread hook that sees BOTH the
+    // parsed scopes and the file text (it already reads `fileContents` for the
+    // package clause). `detectGoInterfaceImplementations` runs later in the same
+    // pass and is the only reader. See `stampGoInterfaceTypeParameters`.
+    (0, generic_type_parameters_js_1.stampGoInterfaceTypeParameters)(parsedFiles, ctx.fileContents);
+    const filesByPackage = new Map();
+    // A file with no resolvable package clause is dropped from ownership
+    // resolution entirely — its methods never attach to a struct declared in a
+    // sibling file. That used to be a bare `continue` with no trace, which is the
+    // same false-safe silence #2813 was filed about. Report it once, bounded
+    // (mirrors the fan-out-cap warning in scope-resolution/pipeline/run.ts).
+    let skippedCount = 0;
+    const skippedSample = [];
+    for (const parsed of parsedFiles) {
+        const pkgName = (0, package_clause_js_1.inferGoPackageName)(ctx.fileContents.get(parsed.filePath) ?? '');
+        if (pkgName === null) {
+            // Count everything, retain only the sample — a misrouted vendored tree
+            // would otherwise accumulate one path reference per file to print five.
+            skippedCount += 1;
+            if (skippedSample.length < SKIPPED_SAMPLE_CAP)
+                skippedSample.push(parsed.filePath);
+            continue;
+        }
+        const key = `${(0, package_clause_js_1.goPackageDir)(parsed.filePath)}\0${pkgName}`;
+        const bucket = filesByPackage.get(key) ?? [];
+        bucket.push(parsed);
+        filesByPackage.set(key, bucket);
+    }
+    if (skippedCount > 0) {
+        logger_js_1.logger.warn({ skippedFiles: skippedCount, sample: skippedSample }, 'go: files with no resolvable package clause were excluded from method-owner ' +
+            'resolution (their methods cannot attach to structs declared in sibling files)');
+    }
+    for (const bucket of filesByPackage.values()) {
+        populateGoOwnersInPackage(bucket);
+    }
+}
+function populateGoOwnersInPackage(parsedFiles) {
+    // Build struct name → def map from ALL scopes' ownedDefs (struct defs
+    // live in Class scopes now, not Module scope).
+    const structByQualifiedName = new Map();
+    for (const parsed of parsedFiles) {
+        for (const scope of parsed.scopes) {
+            for (const def of scope.ownedDefs) {
+                if ((0, walkers_js_1.isClassLike)(def.type) && def.qualifiedName) {
+                    structByQualifiedName.set(def.qualifiedName, {
+                        nodeId: def.nodeId,
+                        qualifiedName: def.qualifiedName,
+                    });
+                }
+            }
+        }
+    }
+    // 2. Go-specific method owner: each Method def lives in a Function
+    //    scope whose typeBindings carry the self entry (kept there by
+    //    goBindingScopeFor). Match the self rawName against struct defs.
+    if (structByQualifiedName.size > 0) {
+        for (const parsed of parsedFiles) {
+            for (const scope of parsed.scopes) {
+                if (scope.kind !== 'Function')
+                    continue;
+                const methodDefs = scope.ownedDefs.filter((d) => d.type === 'Method' && d.ownerId === undefined);
+                if (methodDefs.length === 0)
+                    continue;
+                // Find the self typeBinding in this Function scope.
+                let receiverType;
+                let receiverKind = 'value';
+                for (const [, tb] of scope.typeBindings) {
+                    if (tb.source === 'self') {
+                        receiverType = tb.rawName;
+                        receiverKind = tb.rawName.trim().startsWith('*') ? 'pointer' : 'value';
+                        break;
+                    }
+                }
+                if (receiverType === undefined)
+                    continue;
+                receiverType = receiverType.replace(/^\*+/, '').trim();
+                let owner = structByQualifiedName.get(receiverType);
+                if (owner === undefined) {
+                    for (const [qname, candidate] of structByQualifiedName) {
+                        if (qname.endsWith('.' + receiverType)) {
+                            owner = candidate;
+                            break;
+                        }
+                    }
+                }
+                if (owner !== undefined) {
+                    for (const def of methodDefs) {
+                        def.ownerId = owner.nodeId;
+                        def.goReceiverKind = receiverKind;
+                        const simpleName = def.qualifiedName?.split('.').pop() ?? def.qualifiedName;
+                        if (simpleName !== undefined && !def.qualifiedName?.includes('.')) {
+                            def.qualifiedName =
+                                `${owner.qualifiedName}.${simpleName}`;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/core/code/engine/core/ingestion/languages/go/namespace-mirror.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mirrorGoNamespaceTypeBindings = mirrorGoNamespaceTypeBindings;
+const imported_return_types_js_1 = require("../../scope-resolution/passes/imported-return-types.js");
+/**
+ * Mirror exported typeBindings from namespace-import target modules
+ * into the importer's module scope.
+ *
+ * Go uses namespace imports (`import "pkg"`) where the target package's
+ * exported symbols are visible as `pkg.Func`. For cross-package return-type
+ * resolution to work, the importer needs the target package's exported
+ * typeBindings (e.g. `NewUser → User`) mirrored into its own module scope.
+ *
+ * Exported-symbol filter: Go uses uppercase first letter for exported names.
+ */
+function mirrorGoNamespaceTypeBindings(parsedFiles, indexes, workspaceIndex) {
+    const moduleScopeByFile = workspaceIndex.moduleScopeByFile;
+    for (const parsed of parsedFiles) {
+        const importerModule = moduleScopeByFile.get(parsed.filePath);
+        if (importerModule === undefined)
+            continue;
+        const moduleEdges = indexes.imports.get(importerModule.id);
+        if (moduleEdges === undefined)
+            continue;
+        const nsTargets = new Map();
+        for (const edge of moduleEdges) {
+            if (edge.kind !== 'namespace' || edge.targetFile === null)
+                continue;
+            let targets = nsTargets.get(edge.localName);
+            if (targets === undefined) {
+                targets = [];
+                nsTargets.set(edge.localName, targets);
+            }
+            if (!targets.includes(edge.targetFile))
+                targets.push(edge.targetFile);
+        }
+        for (const targetFiles of nsTargets.values()) {
+            for (const targetFile of targetFiles) {
+                const sourceModule = moduleScopeByFile.get(targetFile);
+                if (sourceModule === undefined)
+                    continue;
+                for (const [name, ref] of sourceModule.typeBindings) {
+                    if (name.length === 0)
+                        continue;
+                    const first = name[0];
+                    if (first < 'A' || first > 'Z')
+                        continue;
+                    if (importerModule.typeBindings.has(name))
+                        continue;
+                    const terminal = (0, imported_return_types_js_1.followChainPostFinalize)(ref, sourceModule.id, indexes);
+                    importerModule.typeBindings.set(name, terminal);
+                }
+            }
+        }
+    }
+}

package/dist/core/code/engine/core/ingestion/languages/go/package-clause.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Go package-clause resolution — the single derivation of a file's package
+ * identity (#2837).
+ *
+ * Both Go passes that bucket files by package (`populateGoWorkspaceOwners` and
+ * `populateGoPackageSiblings`) previously carried their own byte-identical copy
+ * of this, spelled as one unanchored multiline regex:
+ *
+ *     sourceText.match(/^\s*package\s+([A-Za-z_][A-Za-z0-9_]*)/m)
+ *
+ * With the `m` flag that matches the first line ANYWHERE in the file starting
+ * with `package <ident>` — comment bodies included. Measured against that exact
+ * expression: a header comment containing `package legacy_notes kept for
+ * history` yields `legacy_notes`, and an indented `  package helper old name`
+ * yields `helper`. A file that mis-infers its own package gets a bucket key no
+ * sibling shares, so it is isolated in BOTH passes: its methods never attach to
+ * structs declared in sibling files, and it exchanges no same-package bindings.
+ * Every field-receiver call in it then resolves to nothing, silently — the same
+ * per-file signature #2837 reported.
+ *
+ * The Go spec makes the correct rule exact rather than heuristic: a source
+ * file's first non-comment, non-blank token is `package`. So skip the leading
+ * run of whitespace and comments, then require the very next token to be the
+ * clause. Anything else is `null` — a truncated read, a misrouted non-Go file,
+ * an unparseable header — reported by the caller rather than guessed at.
+ *
+ * ONE rule governs every leniency below (the `\s+` separator, the shebang skip,
+ * CR-only line endings): a file this returns `null` for is dropped from BOTH
+ * passes, so refusing a shape the previous regex accepted is a silent
+ * regression, not a principled tightening. Be no stricter than the grammar.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferGoPackageName = inferGoPackageName;
+exports.goPackageDir = goPackageDir;
+/** Leading trivia: whitespace, `//` lines, block comments. Sticky. */
+const LEADING_TRIVIA = /(?:\s+|\/\/[^\n\r]*|\/\*[\s\S]*?\*\/)*/y;
+/** The clause itself, anchored at the first non-trivia byte. `\s+` (not
+ *  `[ \t]+`) because Go separates tokens by any whitespace: `package\nmain` is
+ *  legal and tree-sitter parses it without error. */
+const PACKAGE_CLAUSE = /package\s+([A-Za-z_][A-Za-z0-9_]*)/y;
+/**
+ * The package name declared by this Go source text, or `null` when its first
+ * real token is not a package clause.
+ *
+ * Only the leading run before the clause is skipped — deliberately NOT a
+ * whole-file comment strip, which would be O(file) on every Go file and would
+ * also have to model string literals to stay correct.
+ */
+function inferGoPackageName(sourceText) {
+    let i = 0;
+    // A leading `#!` line: `gorun`-style scripts carry one. Only a FIRST-line
+    // `#!` is skipped; a `#` anywhere else still ends the scan.
+    if (sourceText.startsWith('#!')) {
+        const eol = sourceText.search(/[\n\r]/);
+        if (eol === -1)
+            return null;
+        i = eol + 1;
+    }
+    // Whitespace (`\s` covers the BOM and every line ending), `//` lines and block
+    // comments — the run a Go file may carry before its clause. Sticky, so the
+    // header is skipped in place without slicing a copy of the file. An
+    // unterminated `/*` or a `//` running to EOF simply leaves `lastIndex` where
+    // the clause cannot match, so neither needs its own early return.
+    LEADING_TRIVIA.lastIndex = i;
+    LEADING_TRIVIA.exec(sourceText);
+    PACKAGE_CLAUSE.lastIndex = LEADING_TRIVIA.lastIndex;
+    return PACKAGE_CLAUSE.exec(sourceText)?.[1] ?? null;
+}
+/**
+ * The directory half of a Go package key. Go package identity is
+ * directory-scoped, so repeated `package main` directories must not see each
+ * other's unqualified names.
+ */
+function goPackageDir(filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    const idx = normalized.lastIndexOf('/');
+    return idx === -1 ? '' : normalized.slice(0, idx);
+}

package/dist/core/code/engine/core/ingestion/languages/go/package-siblings.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.populateGoPackageSiblings = populateGoPackageSiblings;
+const expand_wildcards_js_1 = require("./expand-wildcards.js");
+const package_clause_js_1 = require("./package-clause.js");
+/**
+ * O(n²×d) where n = files per package, d = defs per file.
+ * Acceptable for V1 since Go packages are typically small (< 20 files).
+ * Future optimization: build a name→def inverted index per package to reduce
+ * to O(n×d).
+ */
+function populateGoPackageSiblings(parsedFiles, indexes, ctx) {
+    // 0. Filter out test files — Go _test.go files should not contribute
+    //    same-package sibling bindings to non-test files.
+    const nonTestFiles = parsedFiles.filter((f) => !f.filePath.endsWith('_test.go'));
+    // 1. Expand dot imports first so subsequent same-package sibling
+    //    augmentation can also see dot-imported names.
+    (0, expand_wildcards_js_1.expandGoDotImports)(nonTestFiles, indexes);
+    // 2. Group files by package directory plus package name. Go package
+    //    identity is directory-scoped; repeated `package main` directories
+    //    must not see each other's unqualified names.
+    const packageByFile = new Map();
+    for (const parsed of nonTestFiles) {
+        // Same derivation as `populateGoWorkspaceOwners` — one shared resolver, so
+        // the two passes cannot disagree about a file's package (#2837). The
+        // no-clause case is reported there; warning twice for one fact would be
+        // noise.
+        const pkgName = (0, package_clause_js_1.inferGoPackageName)(ctx.fileContents.get(parsed.filePath) ?? '');
+        if (pkgName !== null) {
+            packageByFile.set(parsed.filePath, `${(0, package_clause_js_1.goPackageDir)(parsed.filePath)}\0${pkgName}`);
+        }
+    }
+    const filesByPackage = new Map();
+    for (const parsed of nonTestFiles) {
+        const pkgName = packageByFile.get(parsed.filePath);
+        if (pkgName === undefined)
+            continue;
+        const list = filesByPackage.get(pkgName) ?? [];
+        list.push({ filePath: parsed.filePath, defs: [...parsed.localDefs] });
+        filesByPackage.set(pkgName, list);
+    }
+    // 2. Use bindingAugmentations channel per I8
+    const augmentations = indexes.bindingAugmentations;
+    for (const [, siblings] of filesByPackage) {
+        for (const target of siblings) {
+            const targetModule = indexes.moduleScopes.byFilePath.get(target.filePath);
+            if (targetModule === undefined)
+                continue;
+            for (const receiver of siblings) {
+                if (receiver.filePath === target.filePath)
+                    continue; // no self-reference
+                const receiverModule = indexes.moduleScopes.byFilePath.get(receiver.filePath);
+                if (receiverModule === undefined)
+                    continue;
+                for (const def of target.defs) {
+                    // Go: same-package sibling files can see ALL names (both
+                    // exported/uppercase and unexported/lowercase). Only cross-
+                    // package visibility requires uppercase first letter.
+                    const name = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+                    if (name === '')
+                        continue;
+                    const bucket = getAugmentationBucket(augmentations, receiverModule, name);
+                    if (bucket.some((b) => b.def.nodeId === def.nodeId))
+                        continue;
+                    bucket.push({ def, origin: 'namespace' });
+                }
+            }
+        }
+    }
+}
+function getAugmentationBucket(augmentations, scopeId, name) {
+    let scopeBindings = augmentations.get(scopeId);
+    if (scopeBindings === undefined) {
+        scopeBindings = new Map();
+        augmentations.set(scopeId, scopeBindings);
+    }
+    let bucketArr = scopeBindings.get(name);
+    if (bucketArr === undefined) {
+        bucketArr = [];
+        scopeBindings.set(name, bucketArr);
+    }
+    return bucketArr;
+}