Add another experiment infer2 (WIP)

README.md

@@ -8,3 +8,53 @@ To build and run the prototype, run:
 pnpm install
 pnpm build-and-run
 ```
+
+## experiment
+
+See: the section under `/src/experiment` and `/src/plugins`.
+
+### The idea
+
+Create a TypeScript plugin which can replace structures like:
+ 
+    infer(factoryFunction)
+ 
+where `factoryFunction` is a mathjs factory function in TypeScript, with something like: 
+ 
+    infer({ signature: factoryFunction })
+ 
+where `signature` is a string containing the type of the factory function and its dependencies.
+ 
+Relevant methods of the TypeScript compiler are: 
+
+```ts
+const program = ts.createProgram(fileNames, options)
+const typeChecker = program.getTypeChecker()
+
+// relevant methods:
+//
+//   typeChecker.getSymbolAtLocation
+//   typeChecker.getTypeOfSymbolAtLocation
+//   typeChecker.getResolvedSignature
+//   typeChecker.getSignaturesOfType
+```
+
+### Status
+
+None of the experiments (`infer1` and `infer2`) are outputting something useful yet. 
+
+
+### How to run
+ 
+    pnpm experiment:infer1
+    pnpm experiment:infer1-direct
+    pnpm experiment:infer2
+ 
+### Read more
+ 
+- https://github.com/microsoft/TypeScript/wiki/Writing-a-Language-Service-Plugin
+- https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API
+- https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#using-the-type-checker
+- https://github.com/Microsoft/TypeScript/wiki/Using-the-Language-Service-API
+- https://stackoverflow.com/questions/63944135/typescript-compiler-api-how-to-get-type-with-resolved-type-arguments
+- https://stackoverflow.com/questions/48886508/typechecker-api-how-do-i-find-inferred-type-arguments-to-a-function

package.json5

@@ -5,8 +5,9 @@
    main: 'index.ts',
    scripts: {
       'build-and-run': 'ttsc -b && node build',
-      'experiment-infer': 'ttsc -b && node build/plugins/infer.js ./src/generic/arithmetic.ts',
-      'experiment-infer-direct': 'ttsc -b && node build/plugins/infer.js ./src/experiment/arithmeticInfer.ts',
+      'experiment:infer1': 'ttsc -b && node build/plugins/infer.js ./src/generic/arithmetic.ts',
+      'experiment:infer1-direct': 'ttsc -b && node build/plugins/infer.js ./src/experiment/arithmeticInfer1.ts',
+      'experiment:infer2': 'ttsc -b && node build/plugins/infer2.js ./src/experiment/arithmeticInfer2.ts',
       test: 'echo "Error: no test specified" && exit 1',
    },
    keywords: [

src/experiment/arithmeticInfer2.ts

@@ -0,0 +1,15 @@
+import { infer } from '../generic/infer'
+import { Dependencies, Signature } from '../interfaces/type'
+
+export type multiplyDep<T> = Dependencies<'multiply', T>
+
+export const square1 =
+   <T>(dep: Dependencies<'multiply', T>): Signature<'square', T> =>
+   z => dep.multiply(z, z)
+
+export const square2 = infer(<T>(dep: {
+  multiply: (a: number, b: number) => number,
+  unaryMinus: (x: number) => number, // just for the experiment
+}): (a: number) => number =>
+  z => dep.multiply(z, z)
+)

src/plugins/infer1.ts

@@ -2,32 +2,6 @@ import { readFileSync } from "fs";
 import * as ts from "typescript";
 import { inspect } from 'util'
 
-/**
- * # The idea
- * 
- * Create a TypeScript plugin which can replace structures like:
- * 
- *    infer(factoryFunction)
- * 
- * where `factoryFunction` is a mathjs factory function in TypeScript, with something like: 
- * 
- *    infer({ signature: factoryFunction })
- * 
- * where `signature` is a string containing the type of the factory function and its dependencies.
- * 
- * # How to run
- * 
- *     pnpm experiment-infer
- *     pnpm experiment-infer-direct
- * 
- * # Read more
- * 
- * - https://github.com/microsoft/TypeScript/wiki/Writing-a-Language-Service-Plugin
- * - https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API
- * - https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#using-the-type-checker
- * - https://github.com/Microsoft/TypeScript/wiki/Using-the-Language-Service-API
- */
-
 export function infer(sourceFile: ts.SourceFile) {
     recurse(sourceFile);
 

src/plugins/infer2.ts

@@ -0,0 +1,74 @@
+import * as ts from "typescript"
+
+// based on: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#using-the-type-checker
+
+infer2(process.argv.slice(2), {
+  target: ts.ScriptTarget.ES5,
+  module: ts.ModuleKind.CommonJS
+})
+
+function infer2(
+  fileNames: string[],
+  options: ts.CompilerOptions
+): void {
+  const program = ts.createProgram(fileNames, options)
+  const typeChecker = program.getTypeChecker()
+
+  for (const sourceFile of program.getSourceFiles()) {
+    if (!sourceFile.isDeclarationFile) {
+      ts.forEachChild(sourceFile, visit)
+    }
+  }
+
+  return
+
+  function visit(node: ts.Node) {
+    // // Only consider exported nodes
+    // if (!isNodeExported(node)) {
+    //   return;
+    // }
+
+    // console.log('Node', node.kind, node?.['name']?.escapedText)
+
+    if (ts.isModuleDeclaration(node)) {
+      // This is a namespace, visit its children
+      console.log('check')
+      ts.forEachChild(node, visit);
+    } else if (ts.isTypeAliasDeclaration(node)) {
+      console.log('isTypeAliasDeclaration', node.name.escapedText)
+
+      let symbol = typeChecker.getSymbolAtLocation(node.name);
+      if (symbol) {
+        const symbolType = typeChecker.getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration)
+        const symbolSignature = typeChecker.getSignaturesOfType(symbolType, ts.SignatureKind.Call)
+
+        // checker.getResolvedSignature(symbol)
+        console.log('symbol', symbol.getName(), symbolSignature) 
+
+        // getTypeOfSymbolAtLocation
+        // getResolvedSignature
+      }
+    } else if (ts.isCallExpression(node)) {
+      console.log('isCallExpression', node.expression)
+    } else if (ts.isFunctionDeclaration(node)) {
+      console.log('isFunctionDeclaration', node.name.escapedText, { typeParameter0: node.typeParameters[0] })
+
+      if (node.name.escapedText === 'infer') {
+        const param0 = node.typeParameters[0]
+        if (ts.isPropertyDeclaration(param0)) {
+          const symbol = typeChecker.getSymbolAtLocation(param0)
+
+          // TODO: get resolving 
+
+          // console.log('getResolvedSignature', typeChecker.getResolvedSignature(node) )
+
+          // const symbolType = typeChecker.getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration)
+          // const symbolSignature = typeChecker.getSignaturesOfType(symbolType, ts.SignatureKind.Call)
+          // console.log('symbol', symbol.getName(), symbolSignature) 
+  
+          // console.log('getSignaturesOfType', typeChecker.getSignaturesOfType(param0)
+        }        
+      }
+    }
+  }
+}