ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലർ API: AST മാനിപ്പുലേഷനും കോഡ് ട്രാൻസ്ഫോർമേഷനും പഠിക്കാം

ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലർ API, ടൈപ്പ്സ്ക്രിപ്റ്റ്, ജാവാസ്ക്രിപ്റ്റ് കോഡുകൾ വിശകലനം ചെയ്യാനും, മാറ്റങ്ങൾ വരുത്താനും, നിർമ്മിക്കാനും ശക്തമായ ഒരു ഇൻ്റർഫേസ് നൽകുന്നു. ഇതിൻ്റെ ഹൃദയഭാഗത്ത് അബ്സ്ട്രാക്റ്റ് സിന്റാക്സ് ട്രീ (AST) ആണ്, ഇത് നിങ്ങളുടെ സോഴ്സ് കോഡിന്റെ ഘടനാപരമായ ഒരു പ്രതിനിധാനമാണ്. AST-യുമായി എങ്ങനെ പ്രവർത്തിക്കണമെന്ന് മനസ്സിലാക്കുന്നത്, ലിന്ററുകൾ, കോഡ് ഫോർമാറ്ററുകൾ, സ്റ്റാറ്റിക് അനലൈസറുകൾ, കസ്റ്റം കോഡ് ജനറേറ്ററുകൾ തുടങ്ങിയ നൂതന ടൂളുകൾ നിർമ്മിക്കാനുള്ള കഴിവുകൾ തുറന്നുതരുന്നു.

എന്താണ് ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലർ API?

ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലർ API എന്നത് ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലറിൻ്റെ ആന്തരിക പ്രവർത്തനങ്ങൾ വെളിപ്പെടുത്തുന്ന ഒരു കൂട്ടം ടൈപ്പ്സ്ക്രിപ്റ്റ് ഇൻ്റർഫേസുകളും ഫംഗ്ഷനുകളുമാണ്. ഇത് ഡെവലപ്പർമാർക്ക് കംപൈലേഷൻ പ്രക്രിയയുമായി പ്രോഗ്രാമാറ്റിക്കായി സംവദിക്കാൻ അനുവദിക്കുന്നു, വെറുതെ കോഡ് കംപൈൽ ചെയ്യുന്നതിനപ്പുറം. ഇത് ഉപയോഗിച്ച് നിങ്ങൾക്ക്:

• കോഡ് വിശകലനം ചെയ്യുക: കോഡിൻ്റെ ഘടന പരിശോധിക്കുക, സാധ്യതയുള്ള പ്രശ്നങ്ങൾ കണ്ടെത്തുക, കൂടാതെ സെമാൻ്റിക് വിവരങ്ങൾ വേർതിരിച്ചെടുക്കുക.
• കോഡ് രൂപാന്തരപ്പെടുത്തുക: നിലവിലുള്ള കോഡിൽ മാറ്റങ്ങൾ വരുത്തുക, പുതിയ ഫീച്ചറുകൾ ചേർക്കുക, അല്ലെങ്കിൽ കോഡ് ഓട്ടോമാറ്റിക്കായി റീഫാക്ടർ ചെയ്യുക.
• കോഡ് നിർമ്മിക്കുക: ടെംപ്ലേറ്റുകൾ അല്ലെങ്കിൽ മറ്റ് ഇൻപുട്ടുകൾ അടിസ്ഥാനമാക്കി ആദ്യം മുതൽ പുതിയ കോഡ് സൃഷ്ടിക്കുക.

കോഡിൻ്റെ ഗുണനിലവാരം മെച്ചപ്പെടുത്തുന്നതിനും, ആവർത്തന സ്വഭാവമുള്ള ജോലികൾ ഓട്ടോമേറ്റ് ചെയ്യുന്നതിനും, ഡെവലപ്പർമാരുടെ കാര്യക്ഷമത വർദ്ധിപ്പിക്കുന്നതിനും ഈ API അത്യാവശ്യമാണ്.

അബ്സ്ട്രാക്റ്റ് സിന്റാക്സ് ട്രീ (AST) മനസ്സിലാക്കൽ

AST എന്നത് നിങ്ങളുടെ കോഡിൻ്റെ ഘടനയുടെ ഒരു ട്രീ പോലെയുള്ള പ്രതിനിധാനമാണ്. ട്രീയിലെ ഓരോ നോഡും ഒരു വേരിയബിൾ ഡിക്ലറേഷൻ, ഒരു ഫംഗ്ഷൻ കോൾ, അല്ലെങ്കിൽ ഒരു കൺട്രോൾ ഫ്ലോ സ്റ്റേറ്റ്മെൻ്റ് പോലുള്ള ഒരു സിന്റാക്റ്റിക് ഘടനയെ പ്രതിനിധീകരിക്കുന്നു. AST-യിൽ സഞ്ചരിക്കാനും അതിൻ്റെ നോഡുകൾ പരിശോധിക്കാനും അവയിൽ മാറ്റങ്ങൾ വരുത്താനും ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലർ API ടൂളുകൾ നൽകുന്നു.

ഈ ലളിതമായ ടൈപ്പ്സ്ക്രിപ്റ്റ് കോഡ് പരിഗണിക്കുക:

function greet(name: string): string {
  return `Hello, ${name}!`;
}

console.log(greet("World"));

ഈ കോഡിനായുള്ള AST, ഫംഗ്ഷൻ ഡിക്ലറേഷൻ, റിട്ടേൺ സ്റ്റേറ്റ്മെൻ്റ്, ടെംപ്ലേറ്റ് ലിറ്ററൽ, console.log കോൾ, കൂടാതെ കോഡിൻ്റെ മറ്റ് ഘടകങ്ങളെയും പ്രതിനിധീകരിക്കും. AST-യെ ദൃശ്യവൽക്കരിക്കുന്നത് വെല്ലുവിളിയാകാം, എന്നാൽ AST എക്സ്പ്ലോറർ (astexplorer.net) പോലുള്ള ടൂളുകൾക്ക് സഹായിക്കാൻ കഴിയും. ഈ ടൂളുകൾ കോഡ് നൽകി അതിൻ്റെ അനുബന്ധ AST ഒരു ഉപയോക്തൃ-സൗഹൃദ ഫോർമാറ്റിൽ കാണാൻ നിങ്ങളെ അനുവദിക്കുന്നു. AST എക്സ്പ്ലോറർ ഉപയോഗിക്കുന്നത് നിങ്ങൾ എങ്ങനെയുള്ള കോഡ് ഘടനയാണ് മാറ്റം വരുത്താൻ പോകുന്നതെന്ന് മനസ്സിലാക്കാൻ സഹായിക്കും.

പ്രധാന AST നോഡ് തരങ്ങൾ

ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലർ API വിവിധ AST നോഡ് തരങ്ങൾ നിർവചിക്കുന്നു, ഓരോന്നും ഓരോ സിന്റാക്റ്റിക് ഘടനയെ പ്രതിനിധീകരിക്കുന്നു. ഇവിടെ ചില സാധാരണ നോഡ് തരങ്ങൾ നൽകുന്നു:

• SourceFile: ഒരു മുഴുവൻ ടൈപ്പ്സ്ക്രിപ്റ്റ് ഫയലിനെയും പ്രതിനിധീകരിക്കുന്നു.
• FunctionDeclaration: ഒരു ഫംഗ്ഷൻ നിർവചനത്തെ പ്രതിനിധീകരിക്കുന്നു.
• VariableDeclaration: ഒരു വേരിയബിൾ ഡിക്ലറേഷനെ പ്രതിനിധീകരിക്കുന്നു.
• Identifier: ഒരു ഐഡൻ്റിഫയറിനെ (ഉദാ: വേരിയബിൾ നാമം, ഫംഗ്ഷൻ നാമം) പ്രതിനിധീകരിക്കുന്നു.
• StringLiteral: ഒരു സ്ട്രിംഗ് ലിറ്ററലിനെ പ്രതിനിധീകരിക്കുന്നു.
• CallExpression: ഒരു ഫംഗ്ഷൻ കോളിനെ പ്രതിനിധീകരിക്കുന്നു.
• ReturnStatement: ഒരു റിട്ടേൺ സ്റ്റേറ്റ്മെൻ്റിനെ പ്രതിനിധീകരിക്കുന്നു.

ഓരോ നോഡ് തരത്തിനും അതിൻ്റെ കോഡ് ഘടകത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ നൽകുന്ന പ്രോപ്പർട്ടികളുണ്ട്. ഉദാഹരണത്തിന്, ഒരു `FunctionDeclaration` നോഡിന് അതിൻ്റെ പേര്, പാരാമീറ്ററുകൾ, റിട്ടേൺ ടൈപ്പ്, ബോഡി എന്നിവയ്ക്കായി പ്രോപ്പർട്ടികൾ ഉണ്ടായിരിക്കാം.

കംപൈലർ API ഉപയോഗിച്ച് തുടങ്ങാം

കംപൈലർ API ഉപയോഗിക്കാൻ തുടങ്ങുന്നതിന്, നിങ്ങൾ ടൈപ്പ്സ്ക്രിപ്റ്റ് ഇൻസ്റ്റാൾ ചെയ്യുകയും ടൈപ്പ്സ്ക്രിപ്റ്റ് സിന്റാക്സിനെക്കുറിച്ച് അടിസ്ഥാനപരമായ ധാരണ ഉണ്ടായിരിക്കുകയും വേണം. ഒരു ടൈപ്പ്സ്ക്രിപ്റ്റ് ഫയൽ വായിച്ച് അതിൻ്റെ AST എങ്ങനെ പ്രിൻ്റ് ചെയ്യാമെന്ന് കാണിക്കുന്ന ഒരു ലളിതമായ ഉദാഹരണം ഇതാ:

import * as ts from "typescript";
import * as fs from "fs";

const fileName = "example.ts";
const sourceCode = fs.readFileSync(fileName, "utf8");

const sourceFile = ts.createSourceFile(
  fileName,
  sourceCode,
  ts.ScriptTarget.ES2015, // ടാർഗെറ്റ് ECMAScript പതിപ്പ്
  true // SetParentNodes: AST-യിൽ പാരൻ്റ് റഫറൻസുകൾ നിലനിർത്താൻ true
);

function printAST(node: ts.Node, indent = 0) {
  const indentStr = "  ".repeat(indent);
  console.log(`${indentStr}${ts.SyntaxKind[node.kind]}`);

  node.forEachChild(child => printAST(child, indent + 1));
}

printAST(sourceFile);

വിശദീകരണം:

1. മൊഡ്യൂളുകൾ ഇമ്പോർട്ട് ചെയ്യുക: `typescript` മൊഡ്യൂളും ഫയൽ സിസ്റ്റം പ്രവർത്തനങ്ങൾക്കായി `fs` മൊഡ്യൂളും ഇമ്പോർട്ട് ചെയ്യുന്നു.
2. സോഴ്സ് ഫയൽ വായിക്കുക: `example.ts` എന്ന ടൈപ്പ്സ്ക്രിപ്റ്റ് ഫയലിൻ്റെ ഉള്ളടക്കം വായിക്കുന്നു. ഇത് പ്രവർത്തിക്കുന്നതിന് നിങ്ങൾ ഒരു `example.ts` ഫയൽ ഉണ്ടാക്കേണ്ടതുണ്ട്.
3. SourceFile സൃഷ്ടിക്കുക: ഒരു `SourceFile` ഒബ്ജക്റ്റ് ഉണ്ടാക്കുന്നു, ഇത് AST-യുടെ റൂട്ടിനെ പ്രതിനിധീകരിക്കുന്നു. `ts.createSourceFile` ഫംഗ്ഷൻ സോഴ്സ് കോഡ് പാഴ്സ് ചെയ്ത് AST ഉണ്ടാക്കുന്നു.
4. AST പ്രിൻ്റ് ചെയ്യുക: AST-യിലൂടെ സഞ്ചരിച്ച് ഓരോ നോഡിൻ്റെയും തരം പ്രിൻ്റ് ചെയ്യുന്ന `printAST` എന്ന റിക്കേഴ്സീവ് ഫംഗ്ഷൻ നിർവചിക്കുന്നു.
5. printAST കോൾ ചെയ്യുക: റൂട്ട് `SourceFile` നോഡിൽ നിന്ന് AST പ്രിൻ്റ് ചെയ്യാൻ `printAST` ഫംഗ്ഷനെ വിളിക്കുന്നു.

ഈ കോഡ് പ്രവർത്തിപ്പിക്കാൻ, ഇത് ഒരു `.ts` ഫയലായി (ഉദാ: `ast-example.ts`) സേവ് ചെയ്യുക, കുറച്ച് ടൈപ്പ്സ്ക്രിപ്റ്റ് കോഡുള്ള ഒരു `example.ts` ഫയൽ ഉണ്ടാക്കുക, എന്നിട്ട് കോഡ് കംപൈൽ ചെയ്ത് റൺ ചെയ്യുക:

tsc ast-example.ts
node ast-example.js

ഇത് നിങ്ങളുടെ `example.ts` ഫയലിൻ്റെ AST കൺസോളിൽ പ്രിൻ്റ് ചെയ്യും. ഔട്ട്പുട്ട് നോഡുകളുടെയും അവയുടെ തരങ്ങളുടെയും ശ്രേണി കാണിക്കും. ഉദാഹരണത്തിന്, അത് `FunctionDeclaration`, `Identifier`, `Block` തുടങ്ങിയ നോഡ് തരങ്ങൾ കാണിച്ചേക്കാം.

AST-യിലൂടെ സഞ്ചരിക്കൽ

AST-യിലൂടെ സഞ്ചരിക്കാൻ കംപൈലർ API നിരവധി വഴികൾ നൽകുന്നു. മുൻ ഉദാഹരണത്തിൽ കാണിച്ചതുപോലെ, `forEachChild` മെത്തേഡ് ഉപയോഗിക്കുന്നതാണ് ഏറ്റവും ലളിതമായ മാർഗ്ഗം. ഈ മെത്തേഡ് ഒരു നോഡിൻ്റെ ഓരോ ചൈൽഡ് നോഡും സന്ദർശിക്കുന്നു.

കൂടുതൽ സങ്കീർണ്ണമായ സഞ്ചാര സാഹചര്യങ്ങൾക്കായി, നിങ്ങൾക്ക് ഒരു `Visitor` പാറ്റേൺ ഉപയോഗിക്കാം. ഒരു വിസിറ്റർ എന്നത് നിർദ്ദിഷ്ട നോഡ് തരങ്ങൾക്കായി വിളിക്കേണ്ട മെത്തേഡുകൾ നിർവചിക്കുന്ന ഒരു ഒബ്ജക്റ്റാണ്. ഇത് സഞ്ചാര പ്രക്രിയയെ കസ്റ്റമൈസ് ചെയ്യാനും നോഡ് തരത്തെ അടിസ്ഥാനമാക്കി പ്രവർത്തനങ്ങൾ നടത്താനും നിങ്ങളെ അനുവദിക്കുന്നു.

import * as ts from "typescript";
import * as fs from "fs";

const fileName = "example.ts";
const sourceCode = fs.readFileSync(fileName, "utf8");

const sourceFile = ts.createSourceFile(
  fileName,
  sourceCode,
  ts.ScriptTarget.ES2015,
  true
);

class IdentifierVisitor {
  visit(node: ts.Node) {
    if (ts.isIdentifier(node)) {
      console.log(`ഐഡൻ്റിഫയർ കണ്ടെത്തി: ${node.text}`);
    }

    ts.forEachChild(node, n => this.visit(n));
  }
}

const visitor = new IdentifierVisitor();
visitor.visit(sourceFile);

വിശദീകരണം:

1. IdentifierVisitor ക്ലാസ്: ഒരു `visit` മെത്തേഡുള്ള `IdentifierVisitor` എന്ന ക്ലാസ് നിർവചിക്കുന്നു.
2. Visit മെത്തേഡ്: `visit` മെത്തേഡ് നിലവിലെ നോഡ് ഒരു `Identifier` ആണോ എന്ന് പരിശോധിക്കുന്നു. ആണെങ്കിൽ, അത് ഐഡൻ്റിഫയറിൻ്റെ ടെക്സ്റ്റ് പ്രിൻ്റ് ചെയ്യുന്നു. തുടർന്ന് ചൈൽഡ് നോഡുകൾ സന്ദർശിക്കാൻ അത് റിക്കേഴ്സീവായി `ts.forEachChild` വിളിക്കുന്നു.
3. Visitor സൃഷ്ടിക്കുക: `IdentifierVisitor`-ൻ്റെ ഒരു ഇൻസ്റ്റൻസ് ഉണ്ടാക്കുന്നു.
4. സഞ്ചാരം ആരംഭിക്കുക: സഞ്ചാരം ആരംഭിക്കുന്നതിന് `SourceFile`-ൽ `visit` മെത്തേഡ് വിളിക്കുന്നു.

ഈ ഉദാഹരണം AST-യിലെ എല്ലാ ഐഡൻ്റിഫയറുകളും എങ്ങനെ കണ്ടെത്താമെന്ന് കാണിക്കുന്നു. മറ്റ് നോഡ് തരങ്ങൾ കണ്ടെത്താനും വ്യത്യസ്ത പ്രവർത്തനങ്ങൾ നടത്താനും നിങ്ങൾക്ക് ഈ പാറ്റേൺ ഉപയോഗിക്കാം.

AST രൂപാന്തരപ്പെടുത്തൽ

കംപൈലർ API-യുടെ യഥാർത്ഥ ശക്തി AST-യെ രൂപാന്തരപ്പെടുത്താനുള്ള അതിൻ്റെ കഴിവിലാണ്. നിങ്ങളുടെ കോഡിൻ്റെ ഘടനയും പെരുമാറ്റവും മാറ്റാൻ നിങ്ങൾക്ക് AST-യിൽ മാറ്റങ്ങൾ വരുത്താം. കോഡ് റീഫാക്ടറിംഗ് ടൂളുകൾ, കോഡ് ജനറേറ്ററുകൾ, മറ്റ് നൂതന ടൂളുകൾ എന്നിവയുടെ അടിസ്ഥാനം ഇതാണ്.

AST-യെ രൂപാന്തരപ്പെടുത്താൻ, നിങ്ങൾ `ts.transform` ഫംഗ്ഷൻ ഉപയോഗിക്കേണ്ടതുണ്ട്. ഈ ഫംഗ്ഷൻ ഒരു `SourceFile`-ഉം `TransformerFactory` ഫംഗ്ഷനുകളുടെ ഒരു ലിസ്റ്റും എടുക്കുന്നു. ഒരു `TransformerFactory` എന്നത് ഒരു `TransformationContext` എടുത്ത് ഒരു `Transformer` ഫംഗ്ഷൻ നൽകുന്ന ഒരു ഫംഗ്ഷനാണ്. `Transformer` ഫംഗ്ഷനാണ് AST-യിലെ നോഡുകൾ സന്ദർശിക്കുന്നതിനും രൂപാന്തരപ്പെടുത്തുന്നതിനും ഉത്തരവാദി.

ഒരു ടൈപ്പ്സ്ക്രിപ്റ്റ് ഫയലിൻ്റെ തുടക്കത്തിൽ ഒരു കമൻ്റ് എങ്ങനെ ചേർക്കാമെന്ന് കാണിക്കുന്ന ഒരു ലളിതമായ ഉദാഹരണം ഇതാ:

import * as ts from "typescript";
import * as fs from "fs";

const fileName = "example.ts";
const sourceCode = fs.readFileSync(fileName, "utf8");

const sourceFile = ts.createSourceFile(
  fileName,
  sourceCode,
  ts.ScriptTarget.ES2015,
  true
);

const transformerFactory: ts.TransformerFactory = context => {
  return transformer => {
    return node => {
      if (ts.isSourceFile(node)) {
        // ഒരു ലീഡിംഗ് കമൻ്റ് ഉണ്ടാക്കുക
        const comment = ts.addSyntheticLeadingComment(
          node,
          ts.SyntaxKind.MultiLineCommentTrivia,
          " ഈ ഫയൽ ഓട്ടോമാറ്റിക്കായി രൂപാന്തരപ്പെടുത്തി ",
          true // hasTrailingNewLine
        );

        return node;
      }

      return node;
    };
  };
};

const { transformed } = ts.transform(sourceFile, [transformerFactory]);

const printer = ts.createPrinter({
  newLine: ts.NewLineKind.LineFeed
});

const result = printer.printFile(transformed[0]);

fs.writeFileSync("example.transformed.ts", result);

വിശദീകരണം:

1. TransformerFactory: ഒരു `Transformer` ഫംഗ്ഷൻ നൽകുന്ന ഒരു `TransformerFactory` ഫംഗ്ഷൻ നിർവചിക്കുന്നു.
2. Transformer: `Transformer` ഫംഗ്ഷൻ നിലവിലെ നോഡ് ഒരു `SourceFile` ആണോ എന്ന് പരിശോധിക്കുന്നു. ആണെങ്കിൽ, അത് `ts.addSyntheticLeadingComment` ഉപയോഗിച്ച് നോഡിലേക്ക് ഒരു ലീഡിംഗ് കമൻ്റ് ചേർക്കുന്നു.
3. ts.transform: `SourceFile`-ൽ രൂപാന്തരം പ്രയോഗിക്കാൻ `ts.transform` വിളിക്കുന്നു.
4. Printer: രൂപാന്തരപ്പെടുത്തിയ AST-യിൽ നിന്ന് കോഡ് ഉണ്ടാക്കാൻ ഒരു `Printer` ഒബ്ജക്റ്റ് ഉണ്ടാക്കുന്നു.
5. പ്രിൻ്റ് ചെയ്ത് എഴുതുക: രൂപാന്തരപ്പെടുത്തിയ കോഡ് പ്രിൻ്റ് ചെയ്ത് `example.transformed.ts` എന്ന പുതിയ ഫയലിലേക്ക് എഴുതുന്നു.

ഈ ഉദാഹരണം ഒരു ലളിതമായ രൂപാന്തരത്തെ കാണിക്കുന്നു, എന്നാൽ കോഡ് റീഫാക്ടറിംഗ്, ലോഗിംഗ് സ്റ്റേറ്റ്മെൻ്റുകൾ ചേർക്കൽ, അല്ലെങ്കിൽ ഡോക്യുമെൻ്റേഷൻ ഉണ്ടാക്കൽ പോലുള്ള കൂടുതൽ സങ്കീർണ്ണമായ രൂപാന്തരങ്ങൾ നടത്താൻ നിങ്ങൾക്ക് ഇതേ പാറ്റേൺ ഉപയോഗിക്കാം.

നൂതന രൂപാന്തരീകരണ വിദ്യകൾ

കംപൈലർ API ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഉപയോഗിക്കാവുന്ന ചില നൂതന രൂപാന്തരീകരണ വിദ്യകൾ താഴെ പറയുന്നവയാണ്:

• പുതിയ നോഡുകൾ ഉണ്ടാക്കുക: പുതിയ AST നോഡുകൾ ഉണ്ടാക്കാൻ `ts.createXXX` ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുക. ഉദാഹരണത്തിന്, `ts.createVariableDeclaration` ഒരു പുതിയ വേരിയബിൾ ഡിക്ലറേഷൻ നോഡ് ഉണ്ടാക്കുന്നു.
• നോഡുകൾ മാറ്റിസ്ഥാപിക്കുക: `ts.visitEachChild` ഫംഗ്ഷൻ ഉപയോഗിച്ച് നിലവിലുള്ള നോഡുകൾക്ക് പകരം പുതിയ നോഡുകൾ സ്ഥാപിക്കുക.
• നോഡുകൾ ചേർക്കുക: `ts.updateXXX` ഫംഗ്ഷനുകൾ ഉപയോഗിച്ച് AST-യിലേക്ക് പുതിയ നോഡുകൾ ചേർക്കുക. ഉദാഹരണത്തിന്, `ts.updateBlock` ഒരു ബ്ലോക്ക് സ്റ്റേറ്റ്മെൻ്റിനെ പുതിയ സ്റ്റേറ്റ്മെൻ്റുകൾ ഉപയോഗിച്ച് അപ്ഡേറ്റ് ചെയ്യുന്നു.
• നോഡുകൾ നീക്കം ചെയ്യുക: ട്രാൻസ്ഫോർമർ ഫംഗ്ഷനിൽ നിന്ന് `undefined` തിരികെ നൽകി AST-യിൽ നിന്ന് നോഡുകൾ നീക്കം ചെയ്യുക.

കോഡ് നിർമ്മാണം

AST-യെ രൂപാന്തരപ്പെടുത്തിയ ശേഷം, അതിൽ നിന്ന് നിങ്ങൾ കോഡ് ഉണ്ടാക്കേണ്ടതുണ്ട്. ഇതിനായി കംപൈലർ API ഒരു `Printer` ഒബ്ജക്റ്റ് നൽകുന്നു. `Printer` ഒരു AST എടുത്ത് കോഡിൻ്റെ ഒരു സ്ട്രിംഗ് രൂപം ഉണ്ടാക്കുന്നു.

`ts.createPrinter` ഫംഗ്ഷൻ ഒരു `Printer` ഒബ്ജക്റ്റ് ഉണ്ടാക്കുന്നു. ഉപയോഗിക്കേണ്ട ന്യൂലൈൻ ക്യാരക്ടർ, കമൻ്റുകൾ ഉൾപ്പെടുത്തണോ വേണ്ടയോ തുടങ്ങിയ വിവിധ ഓപ്ഷനുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് പ്രിൻ്റർ കോൺഫിഗർ ചെയ്യാൻ കഴിയും.

`printer.printFile` മെത്തേഡ് ഒരു `SourceFile` എടുത്ത് കോഡിൻ്റെ ഒരു സ്ട്രിംഗ് രൂപം തിരികെ നൽകുന്നു. തുടർന്ന് നിങ്ങൾക്ക് ഈ സ്ട്രിംഗ് ഒരു ഫയലിലേക്ക് എഴുതാം.

കംപൈലർ API-യുടെ പ്രായോഗിക ഉപയോഗങ്ങൾ

സോഫ്റ്റ്‌വെയർ ഡെവലപ്മെൻ്റിൽ ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലർ API-ക്ക് നിരവധി പ്രായോഗിക ഉപയോഗങ്ങളുണ്ട്. ഇവിടെ ചില ഉദാഹരണങ്ങൾ:

• ലിന്ററുകൾ: കോഡിംഗ് സ്റ്റാൻഡേർഡുകൾ നടപ്പിലാക്കാനും നിങ്ങളുടെ കോഡിലെ സാധ്യതയുള്ള പ്രശ്നങ്ങൾ കണ്ടെത്താനും കസ്റ്റം ലിന്ററുകൾ നിർമ്മിക്കുക.
• കോഡ് ഫോർമാറ്ററുകൾ: ഒരു നിർദ്ദിഷ്ട സ്റ്റൈൽ ഗൈഡ് അനുസരിച്ച് നിങ്ങളുടെ കോഡ് ഓട്ടോമാറ്റിക്കായി ഫോർമാറ്റ് ചെയ്യാൻ കോഡ് ഫോർമാറ്ററുകൾ ഉണ്ടാക്കുക.
• സ്റ്റാറ്റിക് അനലൈസറുകൾ: നിങ്ങളുടെ കോഡിലെ ബഗുകൾ, സുരക്ഷാ വീഴ്ചകൾ, പെർഫോമൻസ് പ്രശ്നങ്ങൾ എന്നിവ കണ്ടെത്താൻ സ്റ്റാറ്റിക് അനലൈസറുകൾ വികസിപ്പിക്കുക.
• കോഡ് ജനറേറ്ററുകൾ: ടെംപ്ലേറ്റുകളിൽ നിന്നോ മറ്റ് ഇൻപുട്ടുകളിൽ നിന്നോ കോഡ് ഉണ്ടാക്കുക, ആവർത്തന സ്വഭാവമുള്ള ജോലികൾ ഓട്ടോമേറ്റ് ചെയ്യുകയും ബോയിലർപ്ലേറ്റ് കോഡ് കുറയ്ക്കുകയും ചെയ്യുക. ഉദാഹരണത്തിന്, ഒരു ഡിസ്ക്രിപ്ഷൻ ഫയലിൽ നിന്ന് API ക്ലയൻ്റുകളോ ഡാറ്റാബേസ് സ്കീമകളോ ഉണ്ടാക്കുക.
• റീഫാക്ടറിംഗ് ടൂളുകൾ: വേരിയബിളുകളുടെ പേര് മാറ്റാനും, ഫംഗ്ഷനുകൾ എക്സ്ട്രാക്റ്റ് ചെയ്യാനും, ഫയലുകൾക്കിടയിൽ കോഡ് നീക്കാനും ഓട്ടോമാറ്റിക്കായി റീഫാക്ടറിംഗ് ടൂളുകൾ നിർമ്മിക്കുക.
• അന്താരാഷ്ട്രവൽക്കരണം (i18n) ഓട്ടോമേഷൻ: നിങ്ങളുടെ ടൈപ്പ്സ്ക്രിപ്റ്റ് കോഡിൽ നിന്ന് വിവർത്തനം ചെയ്യാവുന്ന സ്ട്രിംഗുകൾ ഓട്ടോമാറ്റിക്കായി എക്സ്ട്രാക്റ്റ് ചെയ്യുകയും വിവിധ ഭാഷകൾക്കായി ലോക്കലൈസേഷൻ ഫയലുകൾ ഉണ്ടാക്കുകയും ചെയ്യുക. ഉദാഹരണത്തിന്, ഒരു `translate()` ഫംഗ്ഷനിലേക്ക് നൽകുന്ന സ്ട്രിംഗുകൾ ഒരു ടൂളിന് സ്കാൻ ചെയ്യാനും അവയെ ഒരു വിവർത്തന റിസോഴ്സ് ഫയലിലേക്ക് ഓട്ടോമാറ്റിക്കായി ചേർക്കാനും കഴിയും.

ഉദാഹരണം: ഒരു ലളിതമായ ലിന്റർ നിർമ്മിക്കൽ

ടൈപ്പ്സ്ക്രിപ്റ്റ് കോഡിൽ ഉപയോഗിക്കാത്ത വേരിയബിളുകൾ പരിശോധിക്കുന്ന ഒരു ലളിതമായ ലിന്റർ നമുക്ക് ഉണ്ടാക്കാം. ഈ ലിന്റർ ഡിക്ലയർ ചെയ്തിട്ടും ഒരിക്കലും ഉപയോഗിക്കാത്ത വേരിയബിളുകളെ കണ്ടെത്തും.

import * as ts from "typescript";
import * as fs from "fs";

const fileName = "example.ts";
const sourceCode = fs.readFileSync(fileName, "utf8");

const sourceFile = ts.createSourceFile(
  fileName,
  sourceCode,
  ts.ScriptTarget.ES2015,
  true
);

function findUnusedVariables(sourceFile: ts.SourceFile) {
  const usedVariables = new Set();

  function visit(node: ts.Node) {
    if (ts.isIdentifier(node)) {
      usedVariables.add(node.text);
    }

    ts.forEachChild(node, visit);
  }

  visit(sourceFile);

  const unusedVariables: string[] = [];

  function checkVariableDeclaration(node: ts.Node) {
    if (ts.isVariableDeclaration(node) && node.name && ts.isIdentifier(node.name)) {
      const variableName = node.name.text;
      if (!usedVariables.has(variableName)) {
        unusedVariables.push(variableName);
      }
    }

    ts.forEachChild(node, checkVariableDeclaration);
  }

  checkVariableDeclaration(sourceFile);

  return unusedVariables;
}

const unusedVariables = findUnusedVariables(sourceFile);

if (unusedVariables.length > 0) {
  console.log("ഉപയോഗിക്കാത്ത വേരിയബിളുകൾ:");
  unusedVariables.forEach(variable => console.log(`- ${variable}`));
} else {
  console.log("ഉപയോഗിക്കാത്ത വേരിയബിളുകൾ കണ്ടെത്തിയില്ല.");
}

വിശദീകരണം:

1. findUnusedVariables ഫംഗ്ഷൻ: ഒരു `SourceFile` ഇൻപുട്ടായി എടുക്കുന്ന `findUnusedVariables` എന്ന ഫംഗ്ഷൻ നിർവചിക്കുന്നു.
2. usedVariables സെറ്റ്: ഉപയോഗിച്ച വേരിയബിളുകളുടെ പേരുകൾ സൂക്ഷിക്കാൻ ഒരു `Set` ഉണ്ടാക്കുന്നു.
3. visit ഫംഗ്ഷൻ: AST-യിലൂടെ സഞ്ചരിച്ച് എല്ലാ ഐഡൻ്റിഫയറുകളുടെയും പേരുകൾ `usedVariables` സെറ്റിലേക്ക് ചേർക്കുന്ന `visit` എന്ന റിക്കേഴ്സീവ് ഫംഗ്ഷൻ നിർവചിക്കുന്നു.
4. checkVariableDeclaration ഫംഗ്ഷൻ: ഒരു വേരിയബിൾ ഡിക്ലറേഷൻ ഉപയോഗിച്ചിട്ടില്ലെങ്കിൽ അത് പരിശോധിക്കുന്ന `checkVariableDeclaration` എന്ന റിക്കേഴ്സീവ് ഫംഗ്ഷൻ നിർവചിക്കുന്നു. ഉപയോഗിച്ചിട്ടില്ലെങ്കിൽ, അത് വേരിയബിളിൻ്റെ പേര് `unusedVariables` അറേയിലേക്ക് ചേർക്കുന്നു.
5. unusedVariables തിരികെ നൽകുക: ഉപയോഗിക്കാത്ത വേരിയബിളുകളുടെ പേരുകളടങ്ങിയ ഒരു അറേ തിരികെ നൽകുന്നു.
6. ഔട്ട്പുട്ട്: ഉപയോഗിക്കാത്ത വേരിയബിളുകൾ കൺസോളിൽ പ്രിൻ്റ് ചെയ്യുന്നു.

ഈ ഉദാഹരണം ഒരു ലളിതമായ ലിന്ററിനെ കാണിക്കുന്നു. മറ്റ് കോഡിംഗ് സ്റ്റാൻഡേർഡുകൾ പരിശോധിക്കാനും നിങ്ങളുടെ കോഡിലെ മറ്റ് സാധ്യതയുള്ള പ്രശ്നങ്ങൾ കണ്ടെത്താനും നിങ്ങൾക്ക് ഇത് വികസിപ്പിക്കാം. ഉദാഹരണത്തിന്, ഉപയോഗിക്കാത്ത ഇമ്പോർട്ടുകൾ, അമിതമായി സങ്കീർണ്ണമായ ഫംഗ്ഷനുകൾ, അല്ലെങ്കിൽ സാധ്യതയുള്ള സുരക്ഷാ വീഴ്ചകൾ എന്നിവ നിങ്ങൾക്ക് പരിശോധിക്കാം. AST-യിലൂടെ എങ്ങനെ സഞ്ചരിക്കണമെന്നും നിങ്ങൾ താൽപ്പര്യപ്പെടുന്ന നിർദ്ദിഷ്ട നോഡ് തരങ്ങൾ എങ്ങനെ തിരിച്ചറിയണമെന്നും മനസ്സിലാക്കുക എന്നതാണ് പ്രധാനം.

മികച്ച രീതികളും പരിഗണനകളും

• AST മനസ്സിലാക്കുക: AST-യുടെ ഘടന മനസ്സിലാക്കാൻ സമയം ചെലവഴിക്കുക. നിങ്ങളുടെ കോഡിൻ്റെ AST ദൃശ്യവൽക്കരിക്കാൻ AST എക്സ്പ്ലോറർ പോലുള്ള ടൂളുകൾ ഉപയോഗിക്കുക.
• ടൈപ്പ് ഗാർഡുകൾ ഉപയോഗിക്കുക: നിങ്ങൾ ശരിയായ നോഡ് തരങ്ങളുമായി പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കാൻ ടൈപ്പ് ഗാർഡുകൾ (`ts.isXXX`) ഉപയോഗിക്കുക.
• പ്രകടനം പരിഗണിക്കുക: AST രൂപാന്തരങ്ങൾ കമ്പ്യൂട്ടേഷണലായി ചെലവേറിയതാകാം. നിങ്ങൾ സന്ദർശിക്കുകയും രൂപാന്തരപ്പെടുത്തുകയും ചെയ്യുന്ന നോഡുകളുടെ എണ്ണം കുറയ്ക്കുന്നതിന് നിങ്ങളുടെ കോഡ് ഒപ്റ്റിമൈസ് ചെയ്യുക.
• പിശകുകൾ കൈകാര്യം ചെയ്യുക: പിശകുകൾ ഭംഗിയായി കൈകാര്യം ചെയ്യുക. AST-യിൽ അസാധുവായ പ്രവർത്തനങ്ങൾ നടത്താൻ ശ്രമിച്ചാൽ കംപൈലർ API എക്സെപ്ഷനുകൾ നൽകിയേക്കാം.
• സമഗ്രമായി പരിശോധിക്കുക: നിങ്ങളുടെ രൂപാന്തരങ്ങൾ ആവശ്യമുള്ള ഫലങ്ങൾ നൽകുന്നുണ്ടെന്നും പുതിയ ബഗുകൾ ഉണ്ടാക്കുന്നില്ലെന്നും ഉറപ്പാക്കാൻ സമഗ്രമായി പരിശോധിക്കുക.
• നിലവിലുള്ള ലൈബ്രറികൾ ഉപയോഗിക്കുക: കംപൈലർ API-ക്ക് മുകളിൽ ഉയർന്ന തലത്തിലുള്ള അബ്സ്ട്രാക്ഷനുകൾ നൽകുന്ന നിലവിലുള്ള ലൈബ്രറികൾ ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക. ഈ ലൈബ്രറികൾക്ക് സാധാരണ ജോലികൾ ലളിതമാക്കാനും നിങ്ങൾ എഴുതേണ്ട കോഡിൻ്റെ അളവ് കുറയ്ക്കാനും കഴിയും. ഉദാഹരണങ്ങളിൽ `ts-morph`, `typescript-eslint` എന്നിവ ഉൾപ്പെടുന്നു.

ഉപസംഹാരം

നൂതന ഡെവലപ്മെൻ്റ് ടൂളുകൾ നിർമ്മിക്കുന്നതിനുള്ള ശക്തമായ ഒരു ഉപകരണമാണ് ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലർ API. AST-യുമായി എങ്ങനെ പ്രവർത്തിക്കണമെന്ന് മനസ്സിലാക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് ലിന്ററുകൾ, കോഡ് ഫോർമാറ്ററുകൾ, സ്റ്റാറ്റിക് അനലൈസറുകൾ, കൂടാതെ കോഡിൻ്റെ ഗുണനിലവാരം മെച്ചപ്പെടുത്തുകയും ആവർത്തന സ്വഭാവമുള്ള ജോലികൾ ഓട്ടോമേറ്റ് ചെയ്യുകയും ഡെവലപ്പർമാരുടെ കാര്യക്ഷമത വർദ്ധിപ്പിക്കുകയും ചെയ്യുന്ന മറ്റ് ടൂളുകൾ ഉണ്ടാക്കാൻ കഴിയും. API സങ്കീർണ്ണമാണെങ്കിലും, അത് പഠിക്കുന്നതിൻ്റെ പ്രയോജനങ്ങൾ വളരെ വലുതാണ്. ഈ സമഗ്ര ഗൈഡ് നിങ്ങളുടെ പ്രോജക്റ്റുകളിൽ കംപൈലർ API ഫലപ്രദമായി പര്യവേക്ഷണം ചെയ്യുന്നതിനും ഉപയോഗിക്കുന്നതിനും ഒരു അടിത്തറ നൽകുന്നു. AST എക്സ്പ്ലോറർ പോലുള്ള ടൂളുകൾ ഉപയോഗിക്കാനും, നോഡ് തരങ്ങൾ ശ്രദ്ധാപൂർവ്വം കൈകാര്യം ചെയ്യാനും, നിങ്ങളുടെ രൂപാന്തരങ്ങൾ സമഗ്രമായി പരിശോധിക്കാനും ഓർമ്മിക്കുക. പരിശീലനത്തിലൂടെയും അർപ്പണബോധത്തിലൂടെയും, നിങ്ങൾക്ക് ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലർ API-യുടെ മുഴുവൻ സാധ്യതകളും തുറക്കാനും സോഫ്റ്റ്‌വെയർ ഡെവലപ്മെൻ്റ് രംഗത്ത് നൂതനമായ പരിഹാരങ്ങൾ നിർമ്മിക്കാനും കഴിയും.

കൂടുതൽ പഠനത്തിന്:

• ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലർ API ഡോക്യുമെൻ്റേഷൻ: [https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API](https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API)
• AST എക്സ്പ്ലോറർ: [https://astexplorer.net/](https://astexplorer.net/)
• ts-morph ലൈബ്രറി: [https://ts-morph.com/](https://ts-morph.com/)
• typescript-eslint: [https://typescript-eslint.io/](https://typescript-eslint.io/)