டைப்ஸ்கிரிப்ட் கம்பைலர் API: AST கையாளுதல் மற்றும் குறியீடு மாற்றத்தில் தேர்ச்சி பெறுதல்

டைப்ஸ்கிரிப்ட் மற்றும் ஜாவாஸ்கிரிப்ட் குறியீட்டை பகுப்பாய்வு செய்யவும், கையாளவும் மற்றும் உருவாக்கவும் டைப்ஸ்கிரிப்ட் கம்பைலர் API ஒரு சக்திவாய்ந்த இடைமுகத்தை வழங்குகிறது. இதன் மையத்தில் சுருக்க தொடரியல் மரம் (AST) உள்ளது, இது உங்கள் மூலக் குறியீட்டின் ஒரு கட்டமைக்கப்பட்ட பிரதிநிதித்துவம் ஆகும். AST உடன் எப்படி வேலை செய்வது என்பதைப் புரிந்துகொள்வது, லின்டர்கள், குறியீடு வடிவமைப்பாளர்கள், நிலையான பகுப்பாய்விகள் மற்றும் தனிப்பயன் குறியீடு ஜெனரேட்டர்கள் போன்ற மேம்பட்ட கருவிகளை உருவாக்குவதற்கான திறன்களைத் திறக்கிறது.

டைப்ஸ்கிரிப்ட் கம்பைலர் API என்றால் என்ன?

டைப்ஸ்கிரிப்ட் கம்பைலர் API என்பது டைப்ஸ்கிரிப்ட் கம்பைலரின் உள் செயல்பாடுகளை வெளிப்படுத்தும் டைப்ஸ்கிரிப்ட் இடைமுகங்கள் மற்றும் செயல்பாடுகளின் தொகுப்பாகும். இது டெவலப்பர்களை குறியீட்டைத் தொகுப்பதை விட, நிரலாக்க ரீதியாக தொகுத்தல் செயல்முறையுடன் தொடர்பு கொள்ள அனுமதிக்கிறது. நீங்கள் இதை இதற்காகப் பயன்படுத்தலாம்:

• குறியீட்டை பகுப்பாய்வு செய்யுங்கள்: குறியீட்டின் கட்டமைப்பை ஆய்வு செய்யவும், சாத்தியமான சிக்கல்களைக் கண்டறியவும், மற்றும் சொற்பொருள் தகவலைப் பிரித்தெடுக்கவும்.
• குறியீட்டை மாற்றியமைத்தல்: ஏற்கனவே உள்ள குறியீட்டை மாற்றியமைத்தல், புதிய அம்சங்களைச் சேர்ப்பது அல்லது தானாக குறியீட்டை மறுசீரமைத்தல்.
• குறியீட்டை உருவாக்குதல்: டெம்ப்ளேட்கள் அல்லது பிற உள்ளீடுகளின் அடிப்படையில் புதிதாக குறியீட்டை உருவாக்குதல்.

குறியீட்டின் தரத்தை மேம்படுத்தும், திரும்பத் திரும்பச் செய்யும் பணிகளைத் தானியக்கமாக்கும், மற்றும் டெவலப்பர் உற்பத்தித்திறனை மேம்படுத்தும் அதிநவீன மேம்பாட்டுக் கருவிகளை உருவாக்குவதற்கு இந்த API அவசியமானது.

சுருக்க தொடரியல் மரத்தைப் (AST) புரிந்துகொள்ளுதல்

AST என்பது உங்கள் குறியீட்டின் கட்டமைப்பின் ஒரு மரம் போன்ற பிரதிநிதித்துவம் ஆகும். மரத்தில் உள்ள ஒவ்வொரு கணுவும் ஒரு மாறி அறிவிப்பு, ஒரு செயல்பாட்டு அழைப்பு அல்லது ஒரு கட்டுப்பாட்டு ஓட்ட அறிக்கை போன்ற ஒரு தொடரியல் கட்டமைப்பைக் குறிக்கிறது. டைப்ஸ்கிரிப்ட் கம்பைலர் API, AST-ஐ கடந்து செல்லவும், அதன் கணுக்களை ஆய்வு செய்யவும், மற்றும் அவற்றை மாற்றியமைக்கவும் கருவிகளை வழங்குகிறது.

இந்த எளிய டைப்ஸ்கிரிப்ட் குறியீட்டைக் கவனியுங்கள்:

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, // Target ECMAScript version
  true // SetParentNodes: true to retain parent references in the AST
);

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-ஐ அச்சிடுதல்: `printAST` என்ற ஒரு சுழல்நிலை செயல்பாட்டை வரையறுக்கிறது, இது AST-ஐ கடந்து சென்று ஒவ்வொரு கணுவின் வகையையும் அச்சிடுகிறது.
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-ஐ கடந்து செல்லுதல்

கம்பைலர் API ஆனது AST-ஐ கடந்து செல்ல பல வழிகளை வழங்குகிறது. முந்தைய எடுத்துக்காட்டில் காட்டப்பட்டுள்ளபடி, `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(`Found identifier: ${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. விசிட்டரை உருவாக்குதல்: `IdentifierVisitor`-இன் ஒரு நிகழ்வை உருவாக்குகிறது.
4. கடந்து செல்லுதலைத் தொடங்குதல்: கடந்து செல்லுதலைத் தொடங்க `SourceFile`-இல் `visit` முறையை அழைக்கிறது.

இந்த எடுத்துக்காட்டு AST-இல் உள்ள அனைத்து அடையாளங்காட்டிகளையும் எவ்வாறு கண்டுபிடிப்பது என்பதைக் காட்டுகிறது. மற்ற கணு வகைகளைக் கண்டறியவும், வெவ்வேறு செயல்களைச் செய்யவும் நீங்கள் இந்த பேட்டர்னை மாற்றியமைக்கலாம்.

AST-ஐ மாற்றுதல்

கம்பைலர் API-யின் உண்மையான சக்தி AST-ஐ மாற்றும் திறனில் உள்ளது. உங்கள் குறியீட்டின் கட்டமைப்பையும் நடத்தையையும் மாற்ற AST-ஐ நீங்கள் மாற்றியமைக்கலாம். இது குறியீடு மறுசீரமைப்பு கருவிகள், குறியீடு ஜெனரேட்டர்கள் மற்றும் பிற மேம்பட்ட கருவிகளுக்கான அடிப்படையாகும்.

AST-ஐ மாற்ற, நீங்கள் `ts.transform` செயல்பாட்டைப் பயன்படுத்த வேண்டும். இந்தச் செயல்பாடு ஒரு `SourceFile` மற்றும் `TransformerFactory` செயல்பாடுகளின் பட்டியலை எடுக்கும். ஒரு `TransformerFactory` என்பது ஒரு `TransformationContext`-ஐ எடுத்து ஒரு `Transformer` செயல்பாட்டைத் தரும் ஒரு செயல்பாடு ஆகும். `Transformer` செயல்பாடு AST-இல் உள்ள கணுக்களைப் பார்வையிடுவதற்கும் மாற்றுவதற்கும் பொறுப்பாகும்.

ஒரு டைப்ஸ்கிரிப்ட் கோப்பின் தொடக்கத்தில் ஒரு கருத்தை (comment) எவ்வாறு சேர்ப்பது என்பதைக் காட்டும் ஒரு எளிய எடுத்துக்காட்டு இங்கே:

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)) {
        // Create a leading comment
        const comment = ts.addSyntheticLeadingComment(
          node,
          ts.SyntaxKind.MultiLineCommentTrivia,
          " This file was automatically transformed ",
          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("Unused variables:");
  unusedVariables.forEach(variable => console.log(`- ${variable}`));
} else {
  console.log("No unused variables found.");
}

விளக்கம்:

1. findUnusedVariables செயல்பாடு: உள்ளீடாக ஒரு `SourceFile`-ஐ எடுக்கும் `findUnusedVariables` என்ற செயல்பாட்டை வரையறுக்கிறது.
2. usedVariables Set: பயன்படுத்தப்பட்ட மாறிகளின் பெயர்களைச் சேமிக்க ஒரு `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/)