ANTLR/Grammars-v4 ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਟਾਈਪਸਕ੍ਰਿਪਟ ਵਿੱਚ DSL ਨੂੰ ਪਾਰਸ ਕਰਨ ਲਈ ਟੈਸਟ ਚੱਲ ਰਿਹਾ ਹੈ

ANTLR ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਸਟਮ DSLs ਲਈ ਮਾਸਟਰਿੰਗ ਟਾਈਪਸਕ੍ਰਿਪਟ ਪਾਰਸਿੰਗ

ਬੇਸਪੋਕ ਡੋਮੇਨ-ਵਿਸ਼ੇਸ਼ ਭਾਸ਼ਾਵਾਂ (DSLs) ਨਾਲ ਕੰਮ ਕਰਨਾ ਜੋ ਕਿ ਟਾਈਪਸਕ੍ਰਿਪਟ ਵਿਆਕਰਣ ਦੇ ਸਮਾਨ ਹਨ ਸ਼ਕਤੀਸ਼ਾਲੀ ਪਾਰਸਿੰਗ ਟੂਲਸ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ANTLR, ਇੱਕ ਮਜ਼ਬੂਤ ​​ਪਾਰਸਰ ਜਨਰੇਟਰ, ਲੈਕਸਰ ਅਤੇ ਪਾਰਸਰ ਕੰਪੋਨੈਂਟ ਤਿਆਰ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਅਜਿਹੇ DSLs ਨੂੰ TypeScript ਐਬਸਟਰੈਕਟ ਸਿੰਟੈਕਸ ਟ੍ਰੀਜ਼ (ASTs) ਵਿੱਚ ਤਬਦੀਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਇਸਨੂੰ ਟਾਈਪਸਕ੍ਰਿਪਟ ਵਿੱਚ ਲਾਗੂ ਕਰਨਾ ਕੁਝ ਪੇਚੀਦਗੀਆਂ ਪੇਸ਼ ਕਰਦਾ ਹੈ।

ANTLR/Grammars-v4 ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਵਿਆਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਡਿਵੈਲਪਰ.g4 ਫਾਈਲਾਂ ਤੋਂ ਪਾਰਸਰ ਅਤੇ ਲੈਕਸਰ ਬਣਾ ਸਕਦੇ ਹਨ ਜਿਵੇਂ ਕਿ TypeScript Lexer.g4 ਅਤੇ TypeScriptParser.g4. ਇਹਨਾਂ ਫਾਈਲਾਂ ਨੂੰ ਇੱਕ ਸ਼ੁੱਧ TypeScript AST ਨੋਡ ਬਣਾਉਣ ਲਈ ਲੋੜੀਂਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਟਾਈਪ ਪਰਿਭਾਸ਼ਾਵਾਂ ਨਾਲ ਕੰਮ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਸਦੀ ਉਪਯੋਗਤਾ ਦੇ ਬਾਵਜੂਦ, ਗੁੰਝਲਦਾਰ ਤਾਰਾਂ ਨੂੰ ਪਾਰਸ ਕਰਨਾ - ਜਿਵੇਂ ਕਿ ਕਿਸਮ ਘੋਸ਼ਣਾ - ਮੁਸ਼ਕਲ ਹੋ ਸਕਦਾ ਹੈ।

ਵਰਗੀ ਸਤਰ ਨੂੰ ਪਾਰਸ ਕਰਨ ਲਈ ANTLR-ਅਧਾਰਿਤ ਲੈਕਸਰ ਅਤੇ ਪਾਰਸਰ ਦੀ ਵਰਤੋਂ ਕਰਨਾ typeStorage= {todos:Todo[];} ਅਚਾਨਕ ਅਸਫਲਤਾਵਾਂ ਦਾ ਨਤੀਜਾ ਹੋ ਸਕਦਾ ਹੈ। TypeScript ਟੈਸਟਾਂ ਨੂੰ ਕੰਪਾਇਲ ਕਰਦੇ ਸਮੇਂ, ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਆਮ ਤਰੁੱਟੀਆਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈ ਸਕਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਮੇਲ ਖਾਂਦੀਆਂ ਕਿਸਮਾਂ ਜਾਂ ਗੁੰਮ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਟੋਕਨ ਸਰੋਤ, ਪਰਿਣਾਮ ਸਵਰੂਪ ਵਿੱਚ TSError ਸੰਕਲਨ ਦੌਰਾਨ ਸੁਨੇਹੇ.

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਦੇਖਾਂਗੇ ਕਿ ਇਹਨਾਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਕਿਵੇਂ ਹੱਲ ਕਰਨਾ ਹੈ ਅਤੇ ANTLR/Grammars-v4 ਰਿਪੋਜ਼ਟਰੀ ਉਦਾਹਰਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਟੈਸਟਾਂ ਨੂੰ ਕਿਵੇਂ ਚਲਾਉਣਾ ਹੈ। ਅੰਤ ਵਿੱਚ, ਤੁਸੀਂ TypeScript-ਵਰਗੇ DSLs ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਪਾਰਸ ਕਰਨ ਦੇ ਯੋਗ ਹੋਵੋਗੇ।

ਕਸਟਮ DSL ਲਈ ANTLR ਨਾਲ ਟਾਈਪਸਕ੍ਰਿਪਟ ਪਾਰਸਿੰਗ ਨੂੰ ਸਮਝਣਾ

ਦਿੱਤੀਆਂ ਗਈਆਂ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਬੇਸਪੋਕ DSL (ਡੋਮੇਨ-ਵਿਸ਼ੇਸ਼ ਭਾਸ਼ਾ) ਲਈ ਇੱਕ ਲੈਕਸਰ ਅਤੇ ਪਾਰਸਰ ਵਿਕਸਿਤ ਕਰਨ ਲਈ ANTLR ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਜੋ TypeScript ਦੇ ਟਾਈਪ ਸਿਸਟਮ ਦੀ ਨਕਲ ਕਰਦਾ ਹੈ। ਸ਼ੁਰੂਆਤੀ ਪੜਾਅ ਵਿੱਚ ਵਿਆਕਰਣ ਦੇ ਨਿਯਮਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਹੈ TypeScript Lexer.g4 ਅਤੇ TypeScript Parser.g4 ਫਾਈਲਾਂ, ਜੋ ਟੋਕਨਾਈਜ਼ੇਸ਼ਨ ਅਤੇ ਇਨਪੁਟ ਨੂੰ ਪਾਰਸ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੀਆਂ ਹਨ। ਕਮਾਂਡ 'npx antlr4ts TypeScriptLexer.g4 TypeScriptParser.g4' ਲੋੜੀਂਦੀਆਂ TypeScript ਫਾਈਲਾਂ ਤਿਆਰ ਕਰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਲੈਕਸਰ ਅਤੇ ਪਾਰਸਰ ਸ਼ਾਮਲ ਹਨ। ਇਹ ਫ਼ਾਈਲਾਂ 'typeStorage = {todos: Todo[];}' ਵਰਗੀਆਂ ਸਟ੍ਰਿੰਗਾਂ ਨੂੰ ਇੱਕ ਸਟ੍ਰਕਚਰਡ AST (ਐਬਸਟ੍ਰੈਕਟ ਸਿੰਟੈਕਸ ਟ੍ਰੀ) ਦੇ ਤੌਰ 'ਤੇ ਪਾਰਸ ਕਰਦੀਆਂ ਹਨ, ਜੋ ਕਿ ਮਨੁੱਖੀ-ਪੜ੍ਹਨਯੋਗ ਕੋਡ ਨੂੰ ਮਸ਼ੀਨ-ਪੜ੍ਹਨਯੋਗ ਫਾਰਮੈਟ ਵਿੱਚ ਬਦਲਣ ਲਈ ਇੱਕ ਮੁੱਖ ਕਦਮ ਹੈ।

ਬਣਾਇਆ ਗਿਆ ਲੈਕਸਰ ਇਨਪੁਟ ਸਤਰ ਨੂੰ ਟੋਕਨਾਂ ਦੀ ਇੱਕ ਸਟ੍ਰੀਮ ਵਿੱਚ ਬਦਲਦਾ ਹੈ, ਜਿਸਨੂੰ ਪਾਰਸਰ ਫਿਰ '.g4' ਫਾਈਲਾਂ ਵਿੱਚ ਦਰਸਾਏ ਵਿਆਕਰਨਿਕ ਨਿਯਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵਿਆਖਿਆ ਕਰਦਾ ਹੈ। ਸਾਡੀ ਸਕ੍ਰਿਪਟ ਵਿੱਚ, ਅਸੀਂ 'CharStreams.fromString()' ਦੀ ਵਰਤੋਂ ਲੈਕਸਰ ਲਈ ਇੱਕ ਅੱਖਰ ਸਟ੍ਰੀਮ ਵਿੱਚ ਇਨਪੁਟ ਸਟ੍ਰਿੰਗ ਨੂੰ ਬਦਲਣ ਲਈ ਕਰਦੇ ਹਾਂ। ਲੈਕਸਰ ਆਉਟਪੁੱਟ ਦੀ ਵਰਤੋਂ ਫਿਰ a ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਾਮਨ ਟੋਕਨਸਟ੍ਰੀਮ, ਜਿਸ ਨੂੰ ਪਾਰਸਰ ਵਰਤੇਗਾ। ਇੱਕ ਲੈਕਸਰ ਅਤੇ ਟੋਕਨ ਸਟ੍ਰੀਮ ਦਾ ਇਹ ਸੁਮੇਲ ਪਾਰਸਰ ਨੂੰ ਵਿਆਕਰਣ ਨਿਯਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੰਪੁੱਟ ਦੀ ਬਣਤਰ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸਮਝਣ ਦੇ ਯੋਗ ਬਣਾਉਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਕਿਸਮ ਦੇ ਘੋਸ਼ਣਾਵਾਂ ਨੂੰ ਪਛਾਣਨਾ।

ਦੂਜੀ ਸਕ੍ਰਿਪਟ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਮੁੱਦੇ ਨੂੰ ਹੱਲ ਕਰਦੇ ਹਾਂ ਜਿੱਥੇ 'TypeScriptLexer' 'TokenSource' ਇੰਟਰਫੇਸ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਲੈਕਸਰ ਕਲਾਸ ਨੂੰ ਵਧਾ ਕੇ ਅਤੇ 'ਨੇਕਸਟਟੋਕਨ()' ਵਰਗੀਆਂ ਗੁੰਮ ਹੋਈਆਂ ਵਿਧੀਆਂ ਨੂੰ ਪੇਸ਼ ਕਰਕੇ, ਅਸੀਂ ਪੁਸ਼ਟੀ ਕਰਦੇ ਹਾਂ ਕਿ ਲੈਕਸਰ ਟੋਕਨ ਸਰੋਤ ਵਜੋਂ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ। ਇਹ ਕਦਮ ਨਾਜ਼ੁਕ ਹੈ ਕਿਉਂਕਿ ਇਹਨਾਂ ਤਰੀਕਿਆਂ ਤੋਂ ਬਿਨਾਂ, TypeScript ਇੱਕ ਗਲਤੀ ਸੁੱਟ ਦੇਵੇਗਾ, ਜਿਵੇਂ ਕਿ ਗਲਤੀ ਸੁਨੇਹੇ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ 'TypeScriptLexer' ਟਾਈਪ 'TokenSource' ਦੇ ਪੈਰਾਮੀਟਰ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਯੋਗ ਨਹੀਂ ਹੈ। ਕਸਟਮ ਲੈਕਸਰ ਵਿੱਚ ਇਹਨਾਂ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਨਾ ਸੰਕਲਨ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਇੰਪੁੱਟ ਸਟ੍ਰਿੰਗ ਤੋਂ AST ਤੱਕ ਸਹੀ ਪ੍ਰਵਾਹ ਹੋ ਸਕਦਾ ਹੈ।

ਅੰਤ ਵਿੱਚ, ਅੰਤਿਮ ਵਿਕਲਪ ਮੋਚਾ ਟੈਸਟਿੰਗ ਫਰੇਮਵਰਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਯੂਨਿਟ ਟੈਸਟਾਂ ਨੂੰ ਪੇਸ਼ ਕਰਦਾ ਹੈ। ਇਹ ਟੈਸਟ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਨ ਕਿ ਪਾਰਸਰ ਵੱਖ-ਵੱਖ DSL ਸਤਰਾਂ ਦਾ ਸਹੀ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਟੈਸਟ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਸਤਰ 'typeTodo = { title: string; ਪੂਰਾ ਹੋਇਆ: ਬੁਲੀਅਨ; }' ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਪ੍ਰੋਸੈਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਜੇਕਰ ਤਿਆਰ ਕੀਤੀ AST ਅਨੁਮਾਨਿਤ ਬਣਤਰ ਨਾਲ ਮੇਲ ਖਾਂਦੀ ਹੈ। ਇਹ ਰਣਨੀਤੀ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਪਾਰਸਰ ਸਾਰੇ ਸੰਦਰਭਾਂ ਵਿੱਚ ਸਹੀ ਵਿਵਹਾਰ ਕਰਦਾ ਹੈ, ਹੱਲ ਨੂੰ ਵਧੇਰੇ ਲਚਕੀਲਾ ਅਤੇ ਭਰੋਸੇਮੰਦ ਬਣਾਉਂਦਾ ਹੈ। ਬਹੁਤ ਸਾਰੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਨੂੰ ਕਵਰ ਕਰਕੇ, ਅਸੀਂ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਾਂ ਕਿ ਸਾਡਾ ਪਾਰਸਰ ਟਾਈਪ-ਸਕ੍ਰਿਪਟ-ਵਰਗੇ DSL ਸਟ੍ਰਿੰਗਾਂ ਦੀ ਵਿਸ਼ਾਲ ਸ਼੍ਰੇਣੀ ਲਈ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੈ।

// Solution 1: Building a Lexer and Parser in TypeScript Using ANTLR
// Step 1: Install ANTLR TypeScript tools and dependencies
npm install antlr4ts ts-node @types/node
// Step 2: Generate TypeScript lexer and parser from TypeScriptLexer.g4 and TypeScriptParser.g4
npx antlr4ts TypeScriptLexer.g4 TypeScriptParser.g4
// Step 3: Create a parser script (test-parser.ts) to parse custom DSL strings
import { CharStreams, CommonTokenStream } from 'antlr4ts';
import { TypeScriptLexer } from './TypeScriptLexer';
import { TypeScriptParser } from './TypeScriptParser';
const input = 'typeStorage = {todos:Todo[];}';
const lexer = new TypeScriptLexer(CharStreams.fromString(input));
const tokens = new CommonTokenStream(lexer);
const parser = new TypeScriptParser(tokens);
parser.startRule();  // Start parsing
// Test parsing logic with additional DSL strings

// Solution 2: Fixing the TokenSource Issue in TypeScriptLexer
// Ensure TypeScriptLexer implements the necessary methods for TokenSource
import { TokenSource, CharStream, Token } from 'antlr4ts';
class MyLexer extends TypeScriptLexer implements TokenSource {
   nextToken(): Token {
       return super.nextToken();  // Use base class token generation
   }
}
// Create a new instance of MyLexer to bypass the compilation error
const lexer = new MyLexer(CharStreams.fromString(input));
const tokens = new CommonTokenStream(lexer);
const parser = new TypeScriptParser(tokens);
parser.startRule();
// This resolves the missing TokenSource properties issue

// Solution 3: Writing Unit Tests for the TypeScript Parser
import { CharStreams, CommonTokenStream } from 'antlr4ts';
import { TypeScriptLexer } from './TypeScriptLexer';
import { TypeScriptParser } from './TypeScriptParser';
import { expect } from 'chai';
describe('DSL Parser Tests', () => {
   it('should parse type definitions correctly', () => {
       const input = 'typeTodo = { title: string; completed: boolean; }';
       const lexer = new TypeScriptLexer(CharStreams.fromString(input));
       const tokens = new CommonTokenStream(lexer);
       const parser = new TypeScriptParser(tokens);
       const result = parser.startRule();  // Call the start rule of the grammar
       expect(result).to.not.be.null;  // Ensure result is not null
   });
});
// Run the test with Mocha: npx mocha test-parser.ts

ANTLR ਦੇ ਨਾਲ ਟਾਈਪਸਕ੍ਰਿਪਟ ਪਾਰਸਰ ਬਣਾਉਣਾ ਅਤੇ ਟੈਸਟ ਕਰਨਾ: ਉੱਨਤ ਧਾਰਨਾਵਾਂ

TypeScript-ਵਰਗੇ DSLs ਲਈ ਇੱਕ ਪਾਰਸਰ ਵਿਕਸਿਤ ਕਰਦੇ ਸਮੇਂ, ਗੁੰਝਲਦਾਰ ਕਿਸਮ ਦੀਆਂ ਪਰਿਭਾਸ਼ਾਵਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਪ੍ਰੋਸੈਸ ਕਰਨ ਲਈ ਨਾ ਸਿਰਫ਼ ANTLR ਦੇ ਵਿਆਕਰਣ ਡਿਜ਼ਾਈਨ ਨੂੰ ਸਮਝਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਸਗੋਂ ਇਹ ਵੀ ਕਿ ਤਿਆਰ ਕੀਤੇ ਪਾਰਸਰ ਨੂੰ ਹਾਲੀਆ ਟਾਈਪਸਕ੍ਰਿਪਟ ਟੂਲਸ ਨਾਲ ਕਿਵੇਂ ਜੋੜਿਆ ਜਾਵੇ। ਤੋਂ ਲੈਕਸਰ ਅਤੇ ਪਾਰਸਰ ਫਾਈਲਾਂ ਤਿਆਰ ਕਰਨ ਤੋਂ ਇਲਾਵਾ .g4 ਫਾਈਲਾਂ, ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਇਹ ਭਾਗ ਉਹਨਾਂ ਦੇ ਵਿਕਾਸ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਸਹਿਜੇ ਹੀ ਕੰਮ ਕਰਦੇ ਹਨ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਨੇਸਟਡ ਐਲੀਮੈਂਟਸ ਦੇ ਨਾਲ ਟਾਈਪ ਘੋਸ਼ਣਾਵਾਂ ਵਰਗੇ ਆਧੁਨਿਕ ਢਾਂਚੇ ਨੂੰ ਪਾਰਸ ਕਰਦੇ ਹੋਏ। ਇੱਕ ਅਕਸਰ ਅਣਡਿੱਠ ਕੀਤਾ ਹਿੱਸਾ ਪਾਰਸਿੰਗ ਅਸਫਲਤਾਵਾਂ ਦੀ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਡੀਬੱਗਿੰਗ ਹੈ।

ਵਿਆਕਰਣ ਦੇ ਨਿਯਮਾਂ ਅਤੇ ਇਨਪੁਟ ਟੈਕਸਟ ਦੀ ਅਸਲ ਬਣਤਰ ਵਿਚਕਾਰ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ ਪਾਰਸਿੰਗ ਗਲਤੀਆਂ ਦੇ ਆਮ ਕਾਰਨ ਹਨ। ਜੇਕਰ ਲੈਕਸਰ ਅਧੂਰੇ ਜਾਂ ਗਲਤ ਵਿਆਕਰਣ ਨਿਯਮਾਂ ਦੇ ਕਾਰਨ ਗਲਤ ਟੋਕਨ ਤਿਆਰ ਕਰਦਾ ਹੈ, ਤਾਂ ਪਾਰਸਰ ਸਹੀ AST ਨਹੀਂ ਪੈਦਾ ਕਰੇਗਾ। ਇੱਕ DSL ਨੂੰ ਪਾਰਸ ਕਰਨਾ ਜੋ ਆਬਜੈਕਟ-ਵਰਗੇ ਢਾਂਚੇ ਨੂੰ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ TypeScript ਦੀ 'type' ਪਰਿਭਾਸ਼ਾ, ਅਸਫਲ ਹੋ ਸਕਦੀ ਹੈ ਜੇਕਰ ਭਾਸ਼ਾ ਬਹੁਤ ਜ਼ਿਆਦਾ ਨੇਸਟਡ ਬਣਤਰਾਂ ਦਾ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦੀ ਹੈ। ANTLR ਦੇ ਡੀਬੱਗ ਟੂਲਸ ਦੀ ਵਰਤੋਂ ਕਰਨਾ, ਜਿਵੇਂ ਕਿ ANTLRWorks ਪਲੱਗਇਨ, ਟੋਕਨ ਸਟ੍ਰੀਮ ਦੀ ਕਲਪਨਾ ਕਰਨ ਅਤੇ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰ ਸਕਦਾ ਹੈ ਕਿ ਸਮੱਸਿਆ ਕਿੱਥੇ ਮੌਜੂਦ ਹੈ। ਇਹ ਵਿਆਕਰਣ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਠੀਕ ਕਰਨ ਦੇ ਯੋਗ ਬਣਾਉਂਦਾ ਹੈ।

TypeScript ਵਿੱਚ ANTLR ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਇੱਕ ਹੋਰ ਪ੍ਰਮੁੱਖ ਪਹਿਲੂ TypeScript ਈਕੋਸਿਸਟਮ ਨਾਲ ਅਨੁਕੂਲਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਣਾ ਹੈ। ਨਤੀਜੇ ਵਜੋਂ ਪਾਰਸਰ ਨੂੰ ਵਾਧੂ TypeScript ਟੂਲਸ ਨਾਲ ਜੋੜਨ ਵੇਲੇ ਪਹਿਲਾਂ ਵਰਣਿਤ ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਅਤੇ ਟੋਕਨ ਸਰੋਤ ਚਿੰਤਾਵਾਂ ਪ੍ਰਚਲਿਤ ਹੁੰਦੀਆਂ ਹਨ ਜਿਵੇਂ ਕਿ ts-ਨੋਡ. ਲੈਕਸਰ ਦੇ ਗੁੰਮ ਤਰੀਕਿਆਂ (ਜਿਵੇਂ ਪਹਿਲਾਂ ਸਮਝਾਇਆ ਗਿਆ ਹੈ) ਨੂੰ ਵਧਾ ਕੇ ਅਤੇ ਸਹੀ ਢੰਗ ਨਾਲ ਲਾਗੂ ਕਰਕੇ, ਤੁਸੀਂ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹੋ ਕਿ ਇਹ ਟੂਲ ਨਤੀਜੇ ਵਾਲੇ ਪਾਰਸਰ ਨਾਲ ਸਹੀ ਢੰਗ ਨਾਲ ਇੰਟਰਫੇਸ ਕਰਦੇ ਹਨ। ਯੂਨਿਟ ਟੈਸਟ ਫਰੇਮਵਰਕ, ਜਿਵੇਂ ਕਿ ਮੋਚਾ, ਨਾਲ ਟੈਸਟ ਕਰਨਾ, ਇਹ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ ਕਿ ਹੱਲ ਕਈ ਕਿਨਾਰਿਆਂ ਦੇ ਹਾਲਾਤਾਂ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ।