Merge pull request #27 from kylebonnici/fix/include-syntax

Add support for /include/
kylebonnici · Jan 26, 2025 · 2b55798 · 2b55798
2 parents c1d61ef + 8f60f20
commit 2b55798
Show file tree

Hide file tree

Showing 5 changed files with 139 additions and 53 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+# 0.0.9 - 2025-01-26
+
+### Fixed
+
+- Support for `/include/` syntax
+
 # 0.0.8 - 2025-01-26
 
 ### Added

diff --git a/package.json b/package.json
@@ -5,7 +5,7 @@
   "author": "Microsoft Corporation",
   "license": "Apache-2.0",
   "icon": "images/icon.png",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "repository": {
     "type": "git",
     "url": "https://github.com/kylebonnici/dts-lsp"

diff --git a/server/package.json b/server/package.json
@@ -4,7 +4,7 @@
   "author": "Kyle Micallef Bonnici",
   "package-name": "devicetree-language-server",
   "main": "dist/server.js",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "keywords": [
     "dts",
     "devicetree",

diff --git a/server/src/cPreprocessorParser.ts b/server/src/cPreprocessorParser.ts
@@ -20,6 +20,7 @@ import {
   genIssue,
   sameLine,
   validateToken,
+  validateValue,
   validToken,
 } from "./helpers";
 import { ASTBase } from "./ast/base";
@@ -401,15 +402,35 @@ export class CPreprocessorParser extends BaseParser {
     this.enqueueToStack();
 
     const startIndex = this.peekIndex();
-    const start = this.moveToNextToken;
-    let token = start;
-    if (!token || !validToken(token, LexerToken.C_INCLUDE)) {
+    let token = this.currentToken;
+
+    if (!token) {
       this.popStack();
       return false;
     }
 
-    const line = start?.pos.line;
-    const keyword = new Keyword(createTokenIndex(token));
+    let keywordStart = token;
+    let keywordEnd: Token | undefined = token;
+    if (!validToken(token, LexerToken.C_INCLUDE)) {
+      const valid = this.checkConcurrentTokens([
+        validateToken(LexerToken.FORWARD_SLASH),
+        validateValue("include"),
+        validateToken(LexerToken.FORWARD_SLASH),
+      ]);
+
+      if (valid.length !== 3) {
+        this.popStack();
+        return false;
+      }
+
+      keywordStart = valid[0];
+      keywordEnd = valid.at(-1);
+    } else {
+      this.moveToNextToken;
+    }
+
+    const line = keywordStart?.pos.line;
+    const keyword = new Keyword(createTokenIndex(keywordStart, keywordEnd));
 
     token = this.moveToNextToken;
     const pathStart = token;

diff --git a/server/src/test/parser.test.ts b/server/src/test/parser.test.ts
@@ -2102,59 +2102,118 @@ describe("Parser", () => {
     });
 
     describe("Includes", () => {
-      test("Include relative", async () => {
-        mockReadFilesSync({
-          "/folder/dts.dts": '#include "some.dtsi"',
-          "/folder/some.dtsi": "",
+      describe("#include", () => {
+        test("Include relative", async () => {
+          mockReadFilesSync({
+            "/folder/dts.dts": '#include "some.dtsi"',
+            "/folder/some.dtsi": "",
+          });
+          const parser = new CPreprocessorParser("/folder/dts.dts", []);
+          await parser.stable;
+          expect(parser.issues.length).toEqual(0);
+          expect(parser.dtsIncludes.length).toEqual(1);
+          expect(parser.dtsIncludes[0].path.path).toEqual("some.dtsi");
+
+          expect(fs.existsSync).toBeCalledWith("/folder/some.dtsi");
+          expect(fs.readFileSync).nthCalledWith(2, "/folder/some.dtsi");
         });
-        const parser = new CPreprocessorParser("/folder/dts.dts", []);
-        await parser.stable;
-        expect(parser.issues.length).toEqual(0);
-        expect(parser.dtsIncludes.length).toEqual(1);
-        expect(parser.dtsIncludes[0].path.path).toEqual("some.dtsi");
+        test("Include absolute", async () => {
+          mockReadFilesSync({
+            "/folder/dts.dts": "#include <my_includes/some.dtsi>",
+            "/my/includes/my_includes/some.dtsi": "",
+          });
+          const parser = new CPreprocessorParser("/folder/dts.dts", [
+            "/my/includes",
+          ]);
+          await parser.stable;
+          expect(parser.issues.length).toEqual(0);
+          expect(parser.dtsIncludes.length).toEqual(1);
+          expect(parser.dtsIncludes[0].path.path).toEqual(
+            "my_includes/some.dtsi"
+          );
 
-        expect(fs.existsSync).toBeCalledWith("/folder/some.dtsi");
-        expect(fs.readFileSync).nthCalledWith(2, "/folder/some.dtsi");
-      });
-      test("Include absolute", async () => {
-        mockReadFilesSync({
-          "/folder/dts.dts": "#include <my_includes/some.dtsi>",
-          "/my/includes/my_includes/some.dtsi": "",
+          expect(fs.existsSync).toBeCalledWith(
+            "/my/includes/my_includes/some.dtsi"
+          );
+          expect(fs.readFileSync).nthCalledWith(
+            2,
+            "/my/includes/my_includes/some.dtsi"
+          );
         });
-        const parser = new CPreprocessorParser("/folder/dts.dts", [
-          "/my/includes",
-        ]);
-        await parser.stable;
-        expect(parser.issues.length).toEqual(0);
-        expect(parser.dtsIncludes.length).toEqual(1);
-        expect(parser.dtsIncludes[0].path.path).toEqual(
-          "my_includes/some.dtsi"
-        );
 
-        expect(fs.existsSync).toBeCalledWith(
-          "/my/includes/my_includes/some.dtsi"
-        );
-        expect(fs.readFileSync).nthCalledWith(
-          2,
-          "/my/includes/my_includes/some.dtsi"
-        );
+        test("Include absolute", async () => {
+          mockReadFilesSync({
+            "/folder/dts.dts": "#include <my_includes/some.dtsi",
+            "/my/includes/my_includes/some.dtsi": "",
+          });
+          const parser = new CPreprocessorParser("/folder/dts.dts", [
+            "/my/includes",
+          ]);
+          await parser.stable;
+          expect(parser.issues.length).toEqual(1);
+          expect(parser.issues[0].issues).toEqual([SyntaxIssue.GT_SYM]);
+          expect(
+            parser.issues[0].astElement.lastToken.pos.col +
+              parser.issues[0].astElement.lastToken.pos.len
+          ).toEqual(31);
+        });
       });
 
-      test("Include absolute", async () => {
-        mockReadFilesSync({
-          "/folder/dts.dts": "#include <my_includes/some.dtsi",
-          "/my/includes/my_includes/some.dtsi": "",
+      describe("/include/", () => {
+        test("Include relative", async () => {
+          mockReadFilesSync({
+            "/folder/dts.dts": '/include/ "some.dtsi"',
+            "/folder/some.dtsi": "",
+          });
+          const parser = new CPreprocessorParser("/folder/dts.dts", []);
+          await parser.stable;
+          expect(parser.issues.length).toEqual(0);
+          expect(parser.dtsIncludes.length).toEqual(1);
+          expect(parser.dtsIncludes[0].path.path).toEqual("some.dtsi");
+
+          expect(fs.existsSync).toBeCalledWith("/folder/some.dtsi");
+          expect(fs.readFileSync).nthCalledWith(2, "/folder/some.dtsi");
+        });
+        test("Include absolute", async () => {
+          mockReadFilesSync({
+            "/folder/dts.dts": "/include/ <my_includes/some.dtsi>",
+            "/my/includes/my_includes/some.dtsi": "",
+          });
+          const parser = new CPreprocessorParser("/folder/dts.dts", [
+            "/my/includes",
+          ]);
+          await parser.stable;
+          expect(parser.issues.length).toEqual(0);
+          expect(parser.dtsIncludes.length).toEqual(1);
+          expect(parser.dtsIncludes[0].path.path).toEqual(
+            "my_includes/some.dtsi"
+          );
+
+          expect(fs.existsSync).toBeCalledWith(
+            "/my/includes/my_includes/some.dtsi"
+          );
+          expect(fs.readFileSync).nthCalledWith(
+            2,
+            "/my/includes/my_includes/some.dtsi"
+          );
+        });
+
+        test("Include absolute", async () => {
+          mockReadFilesSync({
+            "/folder/dts.dts": "/include/ <my_includes/some.dtsi",
+            "/my/includes/my_includes/some.dtsi": "",
+          });
+          const parser = new CPreprocessorParser("/folder/dts.dts", [
+            "/my/includes",
+          ]);
+          await parser.stable;
+          expect(parser.issues.length).toEqual(1);
+          expect(parser.issues[0].issues).toEqual([SyntaxIssue.GT_SYM]);
+          expect(
+            parser.issues[0].astElement.lastToken.pos.col +
+              parser.issues[0].astElement.lastToken.pos.len
+          ).toEqual(32);
         });
-        const parser = new CPreprocessorParser("/folder/dts.dts", [
-          "/my/includes",
-        ]);
-        await parser.stable;
-        expect(parser.issues.length).toEqual(1);
-        expect(parser.issues[0].issues).toEqual([SyntaxIssue.GT_SYM]);
-        expect(
-          parser.issues[0].astElement.lastToken.pos.col +
-            parser.issues[0].astElement.lastToken.pos.len
-        ).toEqual(31);
       });
     });