Object types come from registered languages

Signed-off-by: worksofliam <[email protected]>

Author: worksofliam

cli/src/builders/environment.ts

@@ -40,10 +40,6 @@ export function getBranchLibraryName(currentBranch: string) {
   return `VS${(str(currentBranch, 0) >>> 0).toString(16).toUpperCase()}`;
 }
 
-export function extCanBeProgram(ext: string): boolean {
-  return ([`MODULE`, `PGM`].includes(getObjectType(ext)));
-}
-
 export function getTrueBasename(name: string) {
   // Logic to handle second extension, caused by bob.
   const sourceObjectTypes = [`.PGM`, `.SRVPGM`, `.TEST`];
@@ -60,55 +56,6 @@ export function getTrueBasename(name: string) {
   return name;
 }
 
-export function getObjectType(ext: string): ObjectType {
-  switch (ext.toLowerCase()) {
-    case `dspf`:
-    case `prtf`:
-    case `pf`:
-    case `lf`:
-    case `sql`:
-    case `table`:
-    case `view`:
-    case `index`:
-    case `alias`:
-    case `sqludf`:
-    case `sqludt`:
-    case `sqlalias`:
-    case `sqlseq`:
-    case `sequence`:
-    case `msgf`:
-      return "FILE";
-
-    case `dtaara`:
-      return "DTAARA";
-
-    case `cmd`:
-      return "CMD";
-
-    case `rpgle`:
-    case `sqlrpgle`:
-    case `clle`:
-    case `cl`:
-      return "MODULE";
-
-    case `binder`:
-    case `bnd`:
-    case `function`:
-      return `SRVPGM`;
-
-    case `procedure`:
-    case `trigger`:
-    case `sqlprc`:
-    case `sqltrg`:
-      return `PGM`;
-
-    case `bnddir`:
-      return `BNDDIR`;
-  }
-
-  return undefined;
-}
-
 export function getDefaultCompiles(): CompileAttribute {
   const binderSourceCompile: CompileData = {
     becomes: `SRVPGM`,

cli/src/languages/rpgle.ts

@@ -1,17 +1,9 @@
 import path from 'path';
-import Cache from "vscode-rpgle/language/models/cache";
-import { IncludeStatement } from "vscode-rpgle/language/parserTypes";
-import { infoOut, warningOut } from '../cli';
-import { DefinitionType, File, Module, CLParser } from 'vscode-clle/language';
-import { DisplayFile as dds } from "vscode-displayfile/src/dspf";
+import { infoOut } from '../cli';
 import Document from "vscode-db2i/src/language/sql/document";
 import { ObjectRef, StatementType } from 'vscode-db2i/src/language/sql/types';
-import Parser from "vscode-rpgle/language/parser";
-import { setupParser } from '../languages/rpgle';
 import { Logger } from '../logger';
-import { asPosix, getReferenceObjectsFrom, getSystemNameFromPath, globalEntryIsValid, toLocalPath, trimQuotes } from '../utils';
-import { extCanBeProgram, getObjectType } from '../builders/environment';
-import { isSqlFunction } from '../languages/sql';
+import { getReferenceObjectsFrom, getSystemNameFromPath, globalEntryIsValid, toLocalPath } from '../utils';
 import { ReadFileSystem } from '../readFileSystem';
 import { TargetsLanguageProvider } from './languages';
 import { sqlExtensions } from './languages/sql';
@@ -150,6 +142,10 @@ export class Targets {
 		await Promise.allSettled(initialFiles.map(f => this.parseFile(f)));
 	}
 
+	private extCanBeProgram(ext: string): boolean {
+		return [`MODULE`, `PGM`].includes(this.languageProvider.getObjectType(ext));
+	}
+
 	public async resolvePathToObject(localPath: string, newText?: string) {
 		if (this.resolvedObjects[localPath]) {
 			if (newText) this.resolvedObjects[localPath].text = newText;
@@ -161,7 +157,7 @@ export class Targets {
 
 		const extension = detail.ext.length > 1 ? detail.ext.substring(1) : detail.ext;
 		const hasProgramAttribute = detail.name.toUpperCase().endsWith(`.PGM`);
-		const isProgram = this.assumePrograms ? extCanBeProgram(extension) : hasProgramAttribute;
+		const isProgram = this.assumePrograms ? this.extCanBeProgram(extension) : hasProgramAttribute;
 		const name = getSystemNameFromPath(hasProgramAttribute ? detail.name.substring(0, detail.name.length - 4) : detail.name);
 		const type: ObjectType = (isProgram ? "PGM" : this.getObjectType(relativePath, extension));
 
@@ -335,7 +331,7 @@ export class Targets {
 
 	// TODO: move this to language provider
 	getObjectType(relativePath: string, ext: string): ObjectType {
-		const objType = getObjectType(ext);
+		const objType = this.languageProvider.getObjectType(ext);
 
 		if (!objType) {
 			this.logger.fileLog(relativePath, {

cli/src/targets/index.ts

@@ -1,40 +1,41 @@
-import { FileOptions, Targets } from ".";
-import { clExtensions, clleTargetCallback } from "./languages/clle";
-import { ddsExtension, ddsTargetCallback } from "./languages/dds";
-import { rpgExtensions, rpgleTargetParser } from "./languages/rpgle";
-import { sqlExtensions, sqlTargetCallback } from "./languages/sql";
-import { binderExtensions, binderTargetCallback } from "./languages/binder";
-import { cmdExtensions, cmdTargetCallback } from "./languages/cmd";
-import { noSourceObjects, noSourceTargetCallback } from "./languages/nosrc";
+import { FileOptions, ObjectType, Targets } from ".";
+import { clExtensions, clleTargetCallback, clObjects } from "./languages/clle";
+import { ddsExtension, ddsObjects, ddsTargetCallback } from "./languages/dds";
+import { rpgExtensions, rpgleTargetParser, rpgObjects } from "./languages/rpgle";
+import { sqlExtensions, sqlObjects, sqlTargetCallback } from "./languages/sql";
+import { binderExtensions, binderObjects, binderTargetCallback } from "./languages/binder";
+import { cmdExtensions, cmdObjects, cmdTargetCallback } from "./languages/cmd";
+import { noSourceObjects, noSourceTargetCallback, noSourceTargetObjects } from "./languages/nosrc";
 
 export type LanguageCallback = (targets: Targets, relativePath: string, content: string, options: FileOptions) => Promise<void>
 interface LanguageGroup {
   extensions: string[];
   callback: LanguageCallback;
 }
 
+export type ExtensionMap = {[ext: string]: ObjectType};
+
 export class TargetsLanguageProvider {
-  private languages: LanguageGroup[] = [
-    {extensions: clExtensions, callback: clleTargetCallback},
-    {extensions: sqlExtensions, callback: sqlTargetCallback},
-    {extensions: ddsExtension, callback: ddsTargetCallback},
-    {extensions: binderExtensions, callback: binderTargetCallback},
-    {extensions: cmdExtensions, callback: cmdTargetCallback},
-    {extensions: noSourceObjects, callback: noSourceTargetCallback}
-  ];
+  private languageTargets: LanguageGroup[] = [];
+  private extensionMap: ExtensionMap = {};
 
   constructor(private readonly targets: Targets) {
     const rpgleTargets = new rpgleTargetParser(this.targets);
-    this.languages.push({
-      extensions: rpgExtensions,
-      callback: (targets, relativePath, content, options) => {
-        return rpgleTargets.rpgleTargetCallback(targets, relativePath, content, options);
-      }
-    })
+
+    this.registerLanguage(clExtensions, clleTargetCallback, clObjects);
+    this.registerLanguage(sqlExtensions, sqlTargetCallback, sqlObjects);
+    this.registerLanguage(ddsExtension, ddsTargetCallback, ddsObjects);
+    this.registerLanguage(binderExtensions, binderTargetCallback, binderObjects);
+    this.registerLanguage(cmdExtensions, cmdTargetCallback, cmdObjects);
+    this.registerLanguage(noSourceObjects, noSourceTargetCallback, noSourceTargetObjects);
+
+    this.registerLanguage(rpgExtensions, (targets, relativePath, content, options) => {
+      return rpgleTargets.rpgleTargetCallback(targets, relativePath, content, options);
+    }, rpgObjects);
   }
 
   public getExtensions() {
-    return this.languages.map(lang => lang.extensions).flat();
+    return this.languageTargets.map(lang => lang.extensions).flat();
   }
 
   public getGlob() {
@@ -44,19 +45,25 @@ export class TargetsLanguageProvider {
 
   public async handleLanguage(relativePath: string, content: string, options: FileOptions = {}) {
     const ext = relativePath.split('.').pop()?.toLowerCase();
-    const language = this.languages.find(lang => lang.extensions.includes(ext));
+    const language = this.languageTargets.find(lang => lang.extensions.includes(ext));
     if (ext && language) {
       await language.callback(this.targets, relativePath, content, options);
     }
   }
 
-  public registerLanguage(extensions: string[], callback: LanguageCallback) {
+  public registerLanguage(extensions: string[], callback: LanguageCallback, objectTypes: ExtensionMap = {}) {
     for (const ext of extensions) {
-      if (this.languages.some(lang => lang.extensions.includes(ext))) {
+      if (this.languageTargets.some(lang => lang.extensions.includes(ext))) {
         throw new Error(`Language with extension '${ext}' is already registered.`);
       }
     }
 
-    this.languages.push({extensions, callback});
+    this.extensionMap = {...this.extensionMap, ...objectTypes};
+
+    this.languageTargets.push({extensions, callback});
+  }
+
+  public getObjectType(ext: string): ObjectType | undefined {
+    return this.extensionMap[ext.toLowerCase()];
   }
 }

cli/src/targets/languages.ts

@@ -3,8 +3,13 @@ import { CLParser, DefinitionType, Module, File } from "vscode-clle/language";
 import { FileOptions, ILEObjectTarget, Targets } from "..";
 import { infoOut } from "../../cli";
 import { trimQuotes } from "../../utils";
+import { ExtensionMap } from "../languages";
 
 export const binderExtensions = [`binder`, `bnd`];
+export const binderObjects: ExtensionMap = {
+  binder: `SRVPGM`,
+  bnd: `SRVPGM`,
+}
 
 export async function binderTargetCallback(targets: Targets, localPath: string, content: string, options: FileOptions) {
   const clDocs = new CLParser();

cli/src/targets/languages/binder.ts

@@ -2,8 +2,14 @@ import path from "path";
 import { CLParser, DefinitionType, Module, File } from "vscode-clle/language";
 import { FileOptions, ILEObjectTarget, Targets } from "..";
 import { infoOut } from "../../cli";
+import { ExtensionMap } from "../languages";
 
 export const clExtensions = [`clle`, `cl`, `clp`];
+export const clObjects: ExtensionMap = {
+  clle: `MODULE`,
+  cl: `MODULE`,
+  clp: `PGM`
+}
 
 export async function clleTargetCallback(targets: Targets, filePath: string, content: string, options: FileOptions) {
   const clDocs = new CLParser();

cli/src/targets/languages/clle.ts

@@ -1,6 +1,10 @@
 import { FileOptions, Targets } from "..";
+import { ExtensionMap } from "../languages";
 
 export const cmdExtensions = [`cmd`];
+export const cmdObjects: ExtensionMap = {
+  cmd: `CMD`
+}
 
 export async function cmdTargetCallback(targets: Targets, localPath: string, content: string, options: FileOptions) {
   targets.resolvePathToObject(localPath, options.text);

cli/src/targets/languages/cmd.ts

@@ -2,8 +2,15 @@ import path from "path";
 import { DisplayFile as dds } from "vscode-displayfile/src/dspf";
 import { FileOptions, ILEObjectTarget, Targets } from "..";
 import { infoOut } from "../../cli";
+import { ExtensionMap } from "../languages";
 
 export const ddsExtension = [`pf`, `lf`, `dspf`, `prtf`];
+export const ddsObjects: ExtensionMap = {
+  pf: `FILE`,
+  lf: `FILE`,
+  dspf: `FILE`,
+  prtf: `FILE`
+}
 
 export async function ddsTargetCallback(targets: Targets, filePath: string, content: string, options: FileOptions) {
   const eol = content.indexOf(`\r\n`) >= 0 ? `\r\n` : `\n`;

cli/src/targets/languages/dds.ts

@@ -1,6 +1,14 @@
 import { Targets, FileOptions } from "..";
+import { ExtensionMap } from "../languages";
 
 export const noSourceObjects = [`dtaara`, `mnucmd`, `msgf`, `dtaq`, `bnddir`];
+export const noSourceTargetObjects: ExtensionMap = {
+  dtaara: `DTAARA`,
+  mnucmd: `CMD`,
+  msgf: `FILE`,
+  dtaq: `DTAQ`,
+  bnddir: `BNDDIR`
+}
 
 export async function noSourceTargetCallback(targets: Targets, localPath: string, content: string, options: FileOptions) {
   targets.resolvePathToObject(localPath, options.text);

cli/src/targets/languages/nosrc.ts

@@ -5,8 +5,13 @@ import Parser from "vscode-rpgle/language/parser";
 import { IncludeStatement } from "vscode-rpgle/language/parserTypes";
 import { asPosix, toLocalPath, trimQuotes } from "../../utils";
 import { isSqlFunction } from "../../languages/sql";
+import { ExtensionMap } from "../languages";
 
 export const rpgExtensions = [`sqlrpgle`, `rpgle`];
+export const rpgObjects: ExtensionMap = {
+  sqlrpgle: `MODULE`,
+  rpgle: `MODULE`,
+}
 
 interface RpgLookup {
 	lookup: string,