a lot of bug fixes

mug1wara26 · mug1wara26 · commit 9e1260b7e048 · 2025-03-25T00:25:04.000+08:00
diff --git a/server/src/ast.ts b/server/src/ast.ts
@@ -1,9 +1,9 @@
 import { Identifier, Literal, SourceLocation, Node, Position as EsPosition } from 'estree';
-import { AUTOCOMPLETE_TYPES, Chapter, Context, DeclarationKind, DECLARATIONS, DeclarationSymbol, Documentation, ImportedSymbol, NODES, ParameterSymbol } from "./types";
+import { AUTOCOMPLETE_TYPES, Chapter, Context, DeclarationKind, DECLARATIONS, DeclarationSymbol, Documentation, EXPRESSIONS, ImportedSymbol, NODES, ParameterSymbol } from "./types";
 import { autocomplete_labels, builtin_constants, builtin_functions, esPosInSourceLoc, findLastRange, getImportedName, getNodeChildren, isBuiltinConst, isBuiltinFunction, mapDeclarationSymbolToDocumentSymbol, mapMetaToCompletionItemKind, module_autocomplete, moduleExists, rangeToSourceLoc, sourceLocEquals, sourceLocInSourceLoc, sourceLocToRange, vsPosInSourceLoc, vsPosToEsPos } from "./utils";
 import { CompletionItem, Diagnostic, DiagnosticSeverity, DiagnosticTag, DocumentHighlight, DocumentSymbol, Hover, Position, Range, TextEdit, WorkspaceEdit } from "vscode-languageserver";
 import { parse as acornParse, Options } from 'acorn';
-import { parse as looseParse} from 'acorn-loose';
+import { parse as looseParse } from 'acorn-loose';
 import { rules, bannedNodes } from "./rules";
 
 export const DEFAULT_ECMA_VERSION = 6;
@@ -54,7 +54,7 @@ export class AST {
     catch (e) {
       this.ast = looseParse(text, acornOptions) as Node
     }
-    // console.debug(JSON.stringify(this.ast, null, 2));
+    console.debug(JSON.stringify(this.ast, null, 2));
 
     this.context = context;
     this.uri = uri;
@@ -164,7 +164,7 @@ export class AST {
           const variableDeclaration: DeclarationSymbol = {
             name: name,
             scope: parent.loc!,
-            meta: child.kind === "var" || child.kind === "let" ? "let" : "const",
+            meta: child.kind === "var" || child.kind === "let" ? "let" : declaration.init?.type === EXPRESSIONS.LAMBDA ? "func" : "const",
             declarationKind: child.kind === "var" || child.kind === "let" ? DeclarationKind.KIND_LET : DeclarationKind.KIND_CONST,
             range: sourceLocToRange(declaration.loc!),
             selectionRange: sourceLocToRange(declaration.id.loc!),
@@ -173,9 +173,9 @@ export class AST {
           this.addDeclaration(name, variableDeclaration);
 
 
-          if (declaration.init && declaration.init.type == DECLARATIONS.LAMBDA) {
+          if (declaration.init && declaration.init.type == EXPRESSIONS.LAMBDA) {
             const lambda = declaration.init;
-            if (lambda.params.length !== 0) variableDeclaration.parameters = [];
+            variableDeclaration.parameters = [];
 
             lambda.params.forEach(param => {
               if (param.loc) {
@@ -252,9 +252,13 @@ export class AST {
       })
     }
     // Handle anonymous lambdas
-    else if (child.type === DECLARATIONS.LAMBDA && parent.type !== DECLARATIONS.VARIABLE) {
+    else if (child.type === EXPRESSIONS.LAMBDA && parent.type !== DECLARATIONS.VARIABLE) {
       child.params.forEach(param => {
-        const name = (param as Identifier).name;
+        let name = "";
+        if (param.type === NODES.IDENTIFIER)
+          name = param.name
+        else if (param.type === NODES.REST && param.argument.type === NODES.IDENTIFIER)
+          name = param.argument.name
         const param_declaration: DeclarationSymbol = {
           name: name,
           scope: child.body.loc!,
@@ -340,7 +344,7 @@ export class AST {
 
       getNodeChildren(node, true).forEach(node => {
         if (
-          scopeFound 
+          scopeFound
           // We want to ignore scopes where the variable was redeclared
           // This occurs when there is an inner scope in the scope of our declaration, and the child node belongs in that scope
           && !this.declarations.get(identifier.name)?.some(x => !sourceLocEquals(x.scope, declaration.scope) && sourceLocInSourceLoc(x.scope, declaration.scope) && sourceLocInSourceLoc(node.loc!, x.scope))
diff --git a/server/src/rules/arrowFunctionExpression.ts b/server/src/rules/arrowFunctionExpression.ts
@@ -0,0 +1,19 @@
+import { AST } from "../ast";
+import { Context } from "../types";
+import { Rule } from "./rule";
+import { ArrowFunctionExpression, Node } from "estree"
+import { DiagnosticSeverity } from "vscode-languageserver";
+
+export const arrowFunctionExpressionRule = new class extends Rule<ArrowFunctionExpression> {
+    public process(child: ArrowFunctionExpression, parent: Node, context: Context, ast: AST): void {
+        let hasRestElement = false;
+        for (const param of child.params) {
+          if (hasRestElement) {
+            ast.addDiagnostic("No params allowed after rest element", DiagnosticSeverity.Error, { start: param.loc!.start, end: child.params[child.params.length - 1].loc!.end });
+            break;
+          }
+
+          hasRestElement = param.type === "RestElement";
+        }
+    }
+}();
diff --git a/server/src/rules/callExpression.ts b/server/src/rules/callExpression.ts
@@ -17,7 +17,8 @@ export const callExpressionRule = new class extends Rule<CallExpression> {
               const loc = callee.loc;
               let declaration = ast.findDeclarationByName(callee.name, loc)
               if (declaration !== undefined) {
-                if (declaration.meta !== "func")
+                // We cannot check for let because they can be reassigned. Constants assigned to lambdas will still be "func"
+                if (declaration.meta === "const")
                   ast.addDiagnostic(`'${callee.name}' is not a function`, DiagnosticSeverity.Error, loc);
                 if (declaration.parameters !== undefined || declaration.declarationKind === DeclarationKind.KIND_IMPORT) {
                   let hasRestElement = false;
diff --git a/server/src/rules/functionDeclaration.ts b/server/src/rules/functionDeclaration.ts
@@ -19,18 +19,5 @@ export const functionDeclarationRule = new class extends Rule<FunctionDeclaratio
 
           hasRestElement = param.type === "RestElement";
         }
-
-        const paramNames = new Set();
-        for (const param of child.params) {
-          if (param.type === NODES.IDENTIFIER || (param.type === NODES.REST && param.argument.type === NODES.IDENTIFIER)) {
-            const name = param.type === NODES.IDENTIFIER ? param.name : (param.argument as Identifier).name;
-
-            if (paramNames.has(name))
-              ast.addDiagnostic("No duplicate param names", DiagnosticSeverity.Error, param.loc!);
-            else
-              paramNames.add(name);
-          }
-        }
-
     }
 }();
diff --git a/server/src/rules/identifier.ts b/server/src/rules/identifier.ts
@@ -8,8 +8,6 @@ import { Context } from "../types";
 
 export const identifierRule = new class extends Rule<Identifier> {
     public process(child: Identifier, parent: Node, context: Context, ast: AST): void {
-        if (child.name === "eval")
-            ast.addDiagnostic("eval is not allowed", DiagnosticSeverity.Error, child.loc!);
         if (parent.type !== DECLARATIONS.IMPORT) {
             // Ensure that all declarations have been processed
             ast.addDiagnosticCallback((node: Node) => {
diff --git a/server/src/rules/index.ts b/server/src/rules/index.ts
@@ -3,7 +3,7 @@ import { DECLARATIONS, EXPRESSIONS, NODES, STATEMENTS } from '../types';
 import { Rule } from './rule';
 import { binaryExpressionRule } from './binaryExpression';
 import { conditonalExpressionRule } from './conditionalExpression';
-import { literalRule } from './literalExpression';
+import { literalRule } from './literal';
 import { variableDeclarationRule } from './variableDeclaration';
 import { assignmentExpressionRule } from './assignmentExpression';
 import { functionDeclarationRule } from './functionDeclaration';
@@ -21,6 +21,7 @@ import { returnStatementRule } from './returnStatement';
 import { spreadElementRule } from './spreadElement';
 import { templateLiteralRule } from './templateLiteral';
 import { unaryExpressionRule } from './unaryExpression';
+import { arrowFunctionExpressionRule } from './arrowFunctionExpression';
 
 export const rules: Map<string, Rule<Node>> = new Map();
 export const bannedNodes = new Set([
@@ -43,6 +44,7 @@ rules.set(EXPRESSIONS.ASSIGNMENT, assignmentExpressionRule);
 rules.set(EXPRESSIONS.CALL, callExpressionRule);
 rules.set(EXPRESSIONS.MEMBER, memberExpressionRule);
 rules.set(EXPRESSIONS.ARRAY, arrayExpressionRule);
+rules.set(EXPRESSIONS.LAMBDA, arrowFunctionExpressionRule);
 
 rules.set(DECLARATIONS.VARIABLE, variableDeclarationRule);
 rules.set(DECLARATIONS.FUNCTION, functionDeclarationRule);
diff --git a/server/src/rules/literal.ts b/server/src/rules/literal.ts
diff --git a/server/src/rules/memberExpression.ts b/server/src/rules/memberExpression.ts
@@ -2,7 +2,7 @@ import { AST } from "../ast";
 import { Rule } from "./rule";
 import { MemberExpression, Node } from "estree"
 import { DiagnosticSeverity } from "vscode-languageserver";
-import { NODES } from "../types";
+import { EXPRESSIONS, NODES } from "../types";
 import { Chapter, Context } from "../types";
 
 export const memberExpressionRule = new class extends Rule<MemberExpression> {
@@ -13,12 +13,14 @@ export const memberExpressionRule = new class extends Rule<MemberExpression> {
         if (!child.computed)
             ast.addDiagnostic("No dot abbreviations", DiagnosticSeverity.Error, child.loc!);
         else if (child.property.type === NODES.IDENTIFIER && child.property.name === "undefined") 
-            ast.addDiagnostic("Expected integer as array index, got undefined.", DiagnosticSeverity.Error, child.property.loc!);
+            ast.addDiagnostic("Expected non negative integer as array index, got undefined.", DiagnosticSeverity.Error, child.property.loc!);
         else if (child.property.type === NODES.LITERAL) {
             if (typeof child.property.value !== "number")
-                ast.addDiagnostic(`Expected integer as array index, got ${child.property.value === null ? "null" : typeof child.property.value }.`, DiagnosticSeverity.Error, child.property.loc!);
+                ast.addDiagnostic(`Expected non negative integer as array index, got ${child.property.value === null ? "null" : typeof child.property.value }.`, DiagnosticSeverity.Error, child.property.loc!);
             else if (!Number.isSafeInteger(child.property.value))
-                ast.addDiagnostic("Expected integer as array index, got float.", DiagnosticSeverity.Error, child.property.loc!);
+                ast.addDiagnostic("Expected non negative integer as array index, got float.", DiagnosticSeverity.Error, child.property.loc!);
         }
+        else if (child.property.type === EXPRESSIONS.UNARY && child.property.operator === "-" && child.property.argument.type === NODES.LITERAL && typeof child.property.argument.value === "number")
+            ast.addDiagnostic("Expected non negative integer as array index, got negative number.", DiagnosticSeverity.Error, child.property.loc!);
     }
 }();
diff --git a/server/src/rules/templateLiteral.ts b/server/src/rules/templateLiteral.ts
@@ -6,7 +6,8 @@ import { Context } from "../types";
 
 export const templateLiteralRule = new class extends Rule<TemplateLiteral> {
     public process(child: TemplateLiteral, parent: Node, context: Context, ast: AST): void {
-        if (child.expressions.length > 0)
-            ast.addDiagnostic("Expressions not allowed in template literal", DiagnosticSeverity.Error, child.loc!);
+        child.expressions.forEach(expression => {
+            ast.addDiagnostic("Expressions not allowed in template literal", DiagnosticSeverity.Error, expression.loc!);
+        })
     }
 }();
diff --git a/server/src/server.ts b/server/src/server.ts
@@ -78,11 +78,7 @@ connection.onInitialize((params: InitializeParams) => {
       documentHighlightProvider: true,
       documentSymbolProvider: true,
       renameProvider: true,
-      hoverProvider: true,
-      diagnosticProvider: {
-        interFileDependencies: false,
-        workspaceDiagnostics: false
-      }
+      hoverProvider: true
     }
   };
   if (hasWorkspaceFolderCapability) {
diff --git a/server/src/types.ts b/server/src/types.ts
@@ -20,8 +20,7 @@ export enum NODES {
 export enum DECLARATIONS {
     VARIABLE = "VariableDeclaration",
     FUNCTION = "FunctionDeclaration",
-    IMPORT = "ImportDeclaration",
-    LAMBDA = "ArrowFunctionExpression"
+    IMPORT = "ImportDeclaration"
 }
 
 export enum STATEMENTS {
@@ -42,7 +41,8 @@ export enum EXPRESSIONS {
     CALL = "CallExpression",
     ASSIGNMENT = "AssignmentExpression",
     MEMBER = "MemberExpression",
-    ARRAY = "ArrayExpression"
+    ARRAY = "ArrayExpression",
+    LAMBDA = "ArrowFunctionExpression"
 }
 
 export interface DeclarationSymbol {
diff --git a/test_files/equality.sourcejs b/test_files/equality.sourcejs
@@ -0,0 +1,5 @@
+true === 1;
+true === (1 === 1);
+(1 === 1) === undefined;
+1 === undefined;
+"string" === 1;
diff --git a/test_files/functions.sourcejs b/test_files/functions.sourcejs
@@ -1,2 +1,15 @@
+import { black } from "rune";
 function test(arg1, ...args) {
-}
+}
+
+const x = () => return 0
+x();
+
+let y = 1;
+y(); // Runtime error
+
+black();
+
+const z = (arg1, ...arg2, arg3) => {
+    return 1;
+};
