Fix passing variables across compilations (#367)

Author: ntkme

lib/src/function-registry.ts

@@ -18,6 +18,11 @@ import {Value} from './value';
  * execute them.
  */
 export class FunctionRegistry<sync extends 'sync' | 'async'> {
+  /**
+   * The globally unique identifier of the current compilation used for tracking
+   * the ownership of CompilerFunction and CompilerMixin objects.
+   */
+  public readonly compileContext = Symbol();
   private readonly functionsByName = new Map<string, CustomFunction<sync>>();
   private readonly functionsById = new Map<number, CustomFunction<sync>>();
   private readonly idsByFunction = new Map<CustomFunction<sync>, number>();

lib/src/protofier.ts

@@ -44,7 +44,7 @@ export class Protofier {
   get accessedArgumentLists(): number[] {
     return this.argumentLists
       .filter(list => list.keywordsAccessed)
-      .map(list => list.id);
+      .map(list => list.id!);
   }
 
   constructor(
@@ -85,15 +85,21 @@ export class Protofier {
       });
       result.value = {case: 'list', value: list};
     } else if (value instanceof SassArgumentList) {
-      const list = create(proto.Value_ArgumentListSchema, {
-        id: value.id,
-        separator: this.protofySeparator(value.separator),
-        contents: value.asList.map(element => this.protofy(element)).toArray(),
-      });
-      for (const [key, mapValue] of value.keywordsInternal) {
-        list.keywords[key] = this.protofy(mapValue);
+      if (value.compileContext === this.functions.compileContext) {
+        const list = create(proto.Value_ArgumentListSchema, {id: value.id});
+        result.value = {case: 'argumentList', value: list};
+      } else {
+        const list = create(proto.Value_ArgumentListSchema, {
+          separator: this.protofySeparator(value.separator),
+          contents: value.asList
+            .map(element => this.protofy(element))
+            .toArray(),
+        });
+        for (const [key, mapValue] of value.keywordsInternal) {
+          list.keywords[key] = this.protofy(mapValue);
+        }
+        result.value = {case: 'argumentList', value: list};
       }
-      result.value = {case: 'argumentList', value: list};
     } else if (value instanceof SassMap) {
       const map = create(proto.Value_MapSchema, {
         entries: value.contents.toArray().map(([key, value]) => ({
@@ -104,6 +110,11 @@ export class Protofier {
       result.value = {case: 'map', value: map};
     } else if (value instanceof SassFunction) {
       if (value.id !== undefined) {
+        if (value.compileContext !== this.functions.compileContext) {
+          throw utils.compilerError(
+            `Value ${value} does not belong to this compilation`,
+          );
+        }
         const fn = create(proto.Value_CompilerFunctionSchema, value);
         result.value = {case: 'compilerFunction', value: fn};
       } else {
@@ -114,6 +125,11 @@ export class Protofier {
         result.value = {case: 'hostFunction', value: fn};
       }
     } else if (value instanceof SassMixin) {
+      if (value.compileContext !== this.functions.compileContext) {
+        throw utils.compilerError(
+          `Value ${value} does not belong to this compilation`,
+        );
+      }
       const mixin = create(proto.Value_CompilerMixinSchema, value);
       result.value = {case: 'compilerMixin', value: mixin};
     } else if (value instanceof SassCalculation) {
@@ -349,6 +365,7 @@ export class Protofier {
           ),
           separator,
           list.id,
+          this.functions.compileContext,
         );
         this.argumentLists.push(result);
         return result;
@@ -369,15 +386,21 @@ export class Protofier {
         );
 
       case 'compilerFunction':
-        return new SassFunction(value.value.value.id);
+        return new SassFunction(
+          value.value.value.id,
+          this.functions.compileContext,
+        );
 
       case 'hostFunction':
         throw utils.compilerError(
           'The compiler may not send Value.host_function.',
         );
 
       case 'compilerMixin':
-        return new SassMixin(value.value.value.id);
+        return new SassMixin(
+          value.value.value.id,
+          this.functions.compileContext,
+        );
 
       case 'calculation':
         return this.deprotofyCalculation(value.value.value);

lib/src/value/argument-list.ts

@@ -13,13 +13,24 @@ export class SassArgumentList extends SassList {
    * compiler which argument lists have had their keywords accessed during a
    * function call.
    *
-   * The special ID 0 indicates an argument list constructed in the host.
+   * The special undefined indicates an argument list constructed in the host.
    *
    * This is marked as public so that the protofier can access it, but it's not
    * part of the package's public API and should not be accessed by user code.
    * It may be renamed or removed without warning in the future.
    */
-  readonly id: number;
+  readonly id: number | undefined;
+
+  /**
+   * If this argument list is constructed in the compiler, this is the unique
+   * context that the host uses to determine which compilation this argument
+   * list belongs to.
+   *
+   * This is marked as public so that the protofier can access it, but it's not
+   * part of the package's public API and should not be accessed by user code.
+   * It may be renamed or removed without warning in the future.
+   */
+  readonly compileContext: symbol | undefined;
 
   /**
    * The argument list's keywords. This isn't exposed directly so that we can
@@ -54,11 +65,13 @@ export class SassArgumentList extends SassList {
     keywords: Record<string, Value> | OrderedMap<string, Value>,
     separator?: ListSeparator,
     id?: number,
+    compileContext?: symbol,
   ) {
     super(contents, {separator});
     this.keywordsInternal = isOrderedMap(keywords)
       ? keywords
       : OrderedMap(keywords);
-    this.id = id ?? 0;
+    this.id = id;
+    this.compileContext = compileContext;
   }
 }

lib/src/value/function.ts

@@ -19,6 +19,16 @@ export class SassFunction extends Value {
    */
   readonly id: number | undefined;
 
+  /**
+   * If this function is defined in the compiler, this is the unique context
+   * that the host uses to determine which compilation this function belongs to.
+   *
+   * This is marked as public so that the protofier can access it, but it's not
+   * part of the package's public API and should not be accessed by user code.
+   * It may be renamed or removed without warning in the future.
+   */
+  readonly compileContext: symbol | undefined;
+
   /**
    * If this function is defined in the host, this is the signature that
    * describes how to pass arguments to it.
@@ -39,26 +49,32 @@ export class SassFunction extends Value {
    */
   readonly callback: CustomFunction<'sync'> | undefined;
 
-  constructor(id: number);
+  constructor(id: number, compileContext: symbol);
   constructor(signature: string, callback: CustomFunction<'sync'>);
   constructor(
     idOrSignature: number | string,
-    callback?: CustomFunction<'sync'>,
+    callbackOrCompileContext: CustomFunction<'sync'> | symbol,
   ) {
     super();
 
-    if (typeof idOrSignature === 'number') {
+    if (
+      typeof idOrSignature === 'number' &&
+      typeof callbackOrCompileContext === 'symbol'
+    ) {
       this.id = idOrSignature;
+      this.compileContext = callbackOrCompileContext;
     } else {
-      this.signature = idOrSignature;
-      this.callback = callback!;
+      this.signature = idOrSignature as string;
+      this.callback = callbackOrCompileContext as CustomFunction<'sync'>;
     }
   }
 
   equals(other: Value): boolean {
     return this.id === undefined
       ? other === this
-      : other instanceof SassFunction && other.id === this.id;
+      : other instanceof SassFunction &&
+          other.compileContext === this.compileContext &&
+          other.id === this.id;
   }
 
   hashCode(): number {

lib/src/value/mixin.ts

@@ -18,13 +18,28 @@ export class SassMixin extends Value {
    */
   readonly id: number;
 
-  constructor(id: number) {
+  /**
+   * This is the unique context that the host uses to determine which
+   * compilation this mixin belongs to.
+   *
+   * This is marked as public so that the protofier can access it, but it's not
+   * part of the package's public API and should not be accessed by user code.
+   * It may be renamed or removed without warning in the future.
+   */
+  readonly compileContext: symbol;
+
+  constructor(id: number, compileContext: symbol) {
     super();
     this.id = id;
+    this.compileContext = compileContext;
   }
 
   equals(other: Value): boolean {
-    return other instanceof SassMixin && other.id === this.id;
+    return (
+      other instanceof SassMixin &&
+      other.compileContext === this.compileContext &&
+      other.id === this.id
+    );
   }
 
   hashCode(): number {