Propagate This Context Through Check

example/index.ts

@@ -1,29 +1,33 @@
-import { Type, TypeRegistry, Kind, TSchema, SchemaOptions } from '@sinclair/typebox'
+import { Type, Static, TypeRegistry, Kind, TSchema, SchemaOptions } from '@sinclair/typebox'
 import { Value } from '@sinclair/typebox/value'
 
+
+
+
 // Tests:
 // - Check
 // - Create
 // - Transform.Has
 // Todo:
-// - Propogation of This into nested Constructor / Function calls
+// - Propogation of This into nested Constructor / Function revise Compiler implementation.
+// - Check.FromThis. Currently checking thisArgs against value for instance
+//   methods that return 'this'. This is a hack and needs to be revised. Need
+//   to investigate a Type.This()
 
-export class Foo {
-  constructor(public a: number) {
-    console.log('Inside Consructor', a)
-  }
-  method(a: number) {
-    console.log('Inside Method', a, this)
-  }
-}
-// prettier-ignore
-const T = Type.ConstructorCall([1], Type.Object({
-  method: Type.FunctionCall(null, [2], Type.Number())
-}))
 
-const C = Value.Create(T)
 
-const X = new C(1)
-console.log(X.method(12))
+const T = Type.Recursive(This => {
+  return Type.ConstructorCall([], Type.Object({
+    method: Type.FunctionCall([], This),
+  }))
+})
+
+type T = Static<typeof T>
+
+class Test {
+  method(): this {
+    return this
+  }
+}
 
-console.log(Value.Check(T, Foo))
+Value.Check(T, Test) // true

src/type/function-call/function-call.ts

@@ -48,12 +48,11 @@ export interface TFunctionCall<T extends unknown[] = unknown[], U extends TSchem
   [Kind]: 'Call'
   static: StaticFunctionCall<T, U, this['params']>
   functionCall: {
-    thisArg: unknown
     parameters: [...T]
     returns: U
   }
 }
 /** `[JavaScript]` Creates a FunctionCall type */
-export function FunctionCall<T extends unknown[], U extends TSchema>(thisArg: unknown, parameters: [...T], returns: U, options?: SchemaOptions): TFunctionCall<T, U> {
-  return { ...options, [Kind]: 'FunctionCall', functionCall: { thisArg, parameters, returns: CloneType(returns) } } as never
+export function FunctionCall<T extends unknown[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunctionCall<T, U> {
+  return { ...options, [Kind]: 'FunctionCall', functionCall: { parameters, returns: CloneType(returns) } } as never
 }

src/type/guard/type.ts

@@ -276,7 +276,6 @@ export function IsFunctionCall(value: unknown): value is TFunctionCall {
     IsKindOf(value, 'FunctionCall') &&
     ValueGuard.HasPropertyKey(value, 'functionCall') &&
     ValueGuard.IsObject(value.functionCall) && (
-      ValueGuard.HasPropertyKey(value.functionCall, 'thisArg') &&
       ValueGuard.HasPropertyKey(value.functionCall, 'parameters') && 
       ValueGuard.HasPropertyKey(value.functionCall, 'returns') && 
       ValueGuard.IsArray(value.functionCall.parameters) &&

src/type/type/javascript.ts

@@ -63,8 +63,8 @@ export class JavaScriptTypeBuilder extends JsonTypeBuilder {
     return BigInt(options)
   }
   /** `[JavaScript]` Creates a FunctionCall type */
-  public FunctionCall<T extends unknown[], U extends TSchema>(thisArg: unknown, parameters: [...T], returnType: U, options: SchemaOptions = {}): TFunctionCall<T, U> {
-    return FunctionCall(thisArg, parameters, returnType, options)
+  public FunctionCall<T extends unknown[], U extends TSchema>(parameters: [...T], returnType: U, options: SchemaOptions = {}): TFunctionCall<T, U> {
+    return FunctionCall(parameters, returnType, options)
   }
   /** `[JavaScript]` Creates a ConstructorCall type */
   public ConstructorCall<T extends unknown[], U extends TSchema>(parameters: [...T], returnType: U, options: SchemaOptions = {}): TConstructorCall<T, U> {