progress

Author: zkat

src/services/mapCode.ts

@@ -1,36 +1,42 @@
+// import {appendFileSync} from "node:fs";
+
 import {
-    AccessorDeclaration,
+    Block,
+    ClassElement,
     ClassLikeDeclaration,
     createSourceFile,
     EnumDeclaration,
+    factory,
     FileTextChanges,
     forEach,
     forEachChild,
     formatting,
     hasJSDocNodes,
     InterfaceDeclaration,
+    isBlock,
     isClassElement,
     isClassLike,
     isEnumMember,
+    isNamedDeclaration,
     isSourceFileJS,
+    isTypeElement,
     LanguageServiceHost,
-    MethodDeclaration,
+    NamedDeclaration,
     Node,
     NodeArray,
     Program,
-    PropertyDeclaration,
-    PropertyName,
     ScriptTarget,
     SourceFile,
     SourceMapper,
+    Statement,
     SyntaxKind,
     sysLog,
     textChanges,
     TextSpan,
+    TypeElement,
     UserPreferences,
 } from "./_namespaces/ts";
 import { ChangeTracker } from "./textChanges";
-
 // useful stuff:
 // textChanges.ChangeTracker - lots of methods for inserting nodes in the right place.
 // textChanges.ChangeTracker.pushRaw() - to push `updates` before running our analysis.
@@ -55,6 +61,13 @@ export function mapCode(
                         // TODO: uhhh... do something about file-less mappings. Not supported for now.
                         return;
                     }
+                    // appendFileSync("D:\\copilot-results.txt", `--------------------------------------------\n// ${sourceFile.fileName}\n`, "utf8");
+                    // if (focusLocations) {
+                    //     appendFileSync("D:\\copilot-results.txt", `// focusLocations: ${JSON.stringify(focusLocations)}\n`, "utf8")
+                    // }
+                    // for (const content of contents) {
+                    //     appendFileSync("D:\\copilot-results.txt", content + "\n\n", "utf8");
+                    // }
                     const parsed = contents.map(parse);
                     sysLog(`${parsed}`);
                     for (const nodes of parsed) {
@@ -65,7 +78,6 @@ export function mapCode(
         );
     } catch (e) {
         sysLog(`mapCode: ${e}`);
-        // TODO: Should this be null instead?
         return [];
     }
 }
@@ -110,47 +122,52 @@ function placeNodeGroup(file: SourceFile, changeTracker: ChangeTracker, nodes: N
     //    using first and last node from `nodes`. Use node types and names to
     //    match ranges.
     if (isClassElement(nodes[0])) {
-        placeClassNodeGroup(file, changeTracker, nodes, focusLocations);
+        placeClassNodeGroup(file, changeTracker, nodes as NodeArray<ClassElement>, focusLocations);
+    }
+    else if (isTypeElement(nodes[0])) {
+        placeClassNodeGroup(file, changeTracker, nodes as NodeArray<TypeElement>, focusLocations);
     }
     else if (isEnumMember(nodes[0])) {
         placeEnumNodeGroup(file, changeTracker, nodes, focusLocations);
     }
     else {
-        placeStatements(file, changeTracker, nodes, focusLocations);
+        placeStatements(file, changeTracker, nodes as NodeArray<Statement>, focusLocations);
     }
 }
 
-function placeClassNodeGroup(file: SourceFile, changeTracker: ChangeTracker, nodes: NodeArray<Node>, focusLocations?: TextSpan[][]) {
+function placeClassNodeGroup(file: SourceFile, changeTracker: ChangeTracker, nodes: NodeArray<ClassElement> | NodeArray<TypeElement>, focusLocations?: TextSpan[][]) {
     // We have one or more class-ish members.
     //
     // 1. If focusLocations is null/undefined, find the first class in the
     //    SourceFile and insert/replace into that class.
     // 2. If we have focusLocations, go over each one and:
     //   a. Find the nearest class or interface declaration that contains the focusLocation.
     let classOrInterface: ClassLikeDeclaration | InterfaceDeclaration | undefined;
-    if (!focusLocations) {
+    if (!focusLocations || !focusLocations.length) {
         for (const stmt of file.statements) {
             if (isClassLike(stmt)) {
                 classOrInterface = stmt;
                 break;
             }
+            else if (stmt.kind === SyntaxKind.InterfaceDeclaration) {
+                classOrInterface = stmt as InterfaceDeclaration;
+                break;
+            }
         }
     }
     else {
         let node: Node | undefined;
         top: for (const locationGroup of focusLocations) {
             for (const location of locationGroup) {
-                node = getNodeAtPosition(file, location.start);
-                while (node) {
-                    if (isClassLike(node)) {
-                        classOrInterface = node;
-                        break top;
-                    }
-                    else if (node.kind === SyntaxKind.InterfaceDeclaration) {
-                        classOrInterface = node as InterfaceDeclaration;
-                        break top;
-                    }
-                    node = node.parent;
+                node = findAncestor(getNodeAtPosition(file, location.start), node => {
+                    return isClassLike(node) || node.kind === SyntaxKind.InterfaceDeclaration;
+                });
+                if (node && node.kind === SyntaxKind.InterfaceDeclaration) {
+                    classOrInterface = node as InterfaceDeclaration;
+                    break top;
+                } else if (node) {
+                    classOrInterface = node as ClassLikeDeclaration;
+                    break top;
                 }
             }
         }
@@ -160,19 +177,44 @@ function placeClassNodeGroup(file: SourceFile, changeTracker: ChangeTracker, nod
         throw new Error("Failed to find a class or interface to map the given code into.");
     }
     else {
+        const classEls: ClassElement[] = [];
+        const typeEls: TypeElement[] = [];
         top: for (const node of nodes) {
-            const nodeName = getIdentifier(node);
             for (const member of classOrInterface.members) {
-                const memberName = getIdentifier(member);
-                if ((nodeName && memberName && nodeName === memberName) ||
-                    node.kind === SyntaxKind.Constructor && member.kind === SyntaxKind.Constructor) {
-                    // If we have a matching name, do a replace.
+                if (matchNode(node, member, file)) {
+                    // If we have corresponding nodes, replace the old one with the new member.
                     changeTracker.replaceNode(file, member, node)
                     continue top;
                 }
             }
             // Otherwise, we insert this node at the end of the class/interface.
-            changeTracker.insertNodeAtEndOfScope(file, classOrInterface, node);
+            if (isClassElement(node)) {
+                classEls.push(node);
+            }
+            else if (isTypeElement(node)) {
+                typeEls.push(node);
+            }
+        }
+        if (classEls.length || typeEls.length) {
+            if (classOrInterface.members.length === 0) {
+                if (classEls.length) {
+                    const newNode = { ...classOrInterface, members: factory.createNodeArray(classEls) };
+                    changeTracker.replaceNode(file, classOrInterface, newNode)
+                }
+                else {
+                    const newNode = { ...classOrInterface, members: factory.createNodeArray(typeEls) };
+                    changeTracker.replaceNode(file, classOrInterface, newNode)
+                }
+            }
+            else if (classEls.length) {
+                changeTracker.insertNodesAfter(file, classOrInterface.members[classOrInterface.members.length - 1], classEls);
+            }
+            else if (typeEls.length) {
+                changeTracker.insertNodesAfter(file, classOrInterface.members[classOrInterface.members.length - 1], typeEls);
+            }
+            else {
+                throw new Error("Nothing to append");
+            }
         }
     }
 }
@@ -181,8 +223,56 @@ function placeEnumNodeGroup(_file: SourceFile, _changeTracker: ChangeTracker, _n
     throw new Error("Not implemented.");
 }
 
-function placeStatements(_file: SourceFile, _changeTracker: ChangeTracker, _nodes: NodeArray<Node>, _focusLocations?: TextSpan[][]) {
-    throw new Error("Not implemented.");
+function placeStatements(file: SourceFile, changeTracker: ChangeTracker, nodes: NodeArray<Statement>, focusLocations?: TextSpan[][]) {
+    // If there's an empty or null focusLocation, we just shove everything at
+    // the end of the file and call it a day.
+    if (!focusLocations || !focusLocations.length) {
+        changeTracker.insertNodesAtEndOfFile(file, nodes, /*blankLineBetween*/ false);
+        return;
+    }
+
+    // Otherwise, we'll need to find the right place to insert or replace.
+
+    // First, we try and find a nearby frame of reference: are there
+    // declarations with similar names nearby?
+    for (const locationGroup of focusLocations) {
+        for (const location of locationGroup) {
+            const scope: Node | undefined = findAncestor(getNodeAtPosition(file, location.start), node => {
+                if (!isBlock(node)) {
+                    return false;
+                }
+                for (const stmt of node.statements) {
+                    for (const node of nodes) {
+                        if (matchNode(node, stmt, file)) {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            });
+            if (scope) {
+                // We found a scope that contains a matching node.
+
+                // TODO: find range and replaceRangeWithNodes.
+                return;
+            }
+        }
+    }
+
+    // If we have no frame of reference, we'll just insert at the end of the
+    // nearest statements scope, or, if we can't find a block, at the top
+    // level of the source file.
+    let scopeStatements: NodeArray<Statement> = file.statements;
+    top: for (const locationGroup of focusLocations) {
+        for (const location of locationGroup) {
+            const block = findAncestor(getNodeAtPosition(file, location.start), isBlock);
+            if (block) {
+                scopeStatements = (block as Block).statements;
+                break top;
+            }
+        }
+    }
+    changeTracker.insertNodesAfter(file, scopeStatements[scopeStatements.length - 1], nodes);
 }
 
 function getNodeAtPosition(sourceFile: SourceFile, position: number): Node {
@@ -202,33 +292,44 @@ function getNodeAtPosition(sourceFile: SourceFile, position: number): Node {
     }
 }
 
-function getIdentifier(node: Node): string | undefined {
-    let name: PropertyName | undefined;
-    switch (node.kind) {
-        case SyntaxKind.PropertyDeclaration:
-            name = (node as PropertyDeclaration).name;
-            break;
-        case SyntaxKind.MethodDeclaration:
-            name = (node as MethodDeclaration).name;
-            break;
-        case SyntaxKind.GetAccessor:
-        case SyntaxKind.SetAccessor:
-            name = (node as AccessorDeclaration).name;
-            break;
+function getIdentifier(node: NamedDeclaration, file: SourceFile): string | undefined {
+    const name = node.name;
+    if (!name) return undefined;
+    switch (name.kind) {
+        case SyntaxKind.Identifier:
+            return name.text;
+        case SyntaxKind.PrivateIdentifier:
+            return name.escapedText as string;
+        case SyntaxKind.JsxNamespacedName:
+            return name.namespace.text + ":" + name.name.text;
         default:
-            return undefined;
-    }
-    if (name) {
-        switch (name.kind) {
-            case SyntaxKind.Identifier:
-                return name.text;
-            case SyntaxKind.PrivateIdentifier:
-                return name.escapedText as string;
-            case SyntaxKind.StringLiteral:
-            case SyntaxKind.NumericLiteral:
-            case SyntaxKind.ComputedPropertyName:
-                return name.getText();
-        }
+            return name.getText(file);
     }
 }
 
+function matchNode(a: Node, b: Node, file: SourceFile): boolean {
+    if (a.kind !== b.kind) {
+        return false;
+    }
+    if (a.kind === SyntaxKind.Constructor) {
+        return a.kind === b.kind;
+    }
+
+    if (isNamedDeclaration(a) && isNamedDeclaration(b)) {
+        const aName = getIdentifier(a, file);
+        const bName = getIdentifier(b, file);
+        return !!(aName && bName && aName === bName);
+    }
+
+    // TODO: Maybe match by other characteristics?
+    return false;
+}
+
+function findAncestor(node: Node, f: (node: Node) => boolean): Node | undefined {
+    while (node) {
+        if (f(node)) {
+            return node;
+        }
+        node = node.parent;
+    }
+}