Support tuple and set for constant generation (#290)

Co-authored-by: jayaprabhakar <jayaprabhakar@gmail.com>

Author: jp-fizzbee

mbt/lib/shared/proto/mbt_plugin.proto

@@ -23,6 +23,8 @@ message Value {
     MapValue map_value = 4;
     ListValue list_value = 5;
     SentinelType sentinel_value = 6;  // Sentinel for flexible state matching
+    TupleValue tuple_value = 7;  // Tuple (immutable sequence)
+    SetValue set_value = 8;  // Set (unique elements)
   }
 }
 
@@ -39,6 +41,10 @@ message ListValue {
   repeated Value items = 1;
 }
 
+message TupleValue {
+  repeated Value items = 1;
+}
+
 message SetValue {
   repeated Value items = 1;
 }

mbt/lib/typescript/src/index.ts

@@ -27,7 +27,8 @@ export {
   Arg,
   RoleId,
   NotImplementedError,
-  MbtError
+  MbtError,
+  Tuple
 } from './types';
 
 // Runner

mbt/lib/typescript/src/overrides.ts

@@ -1,3 +1,5 @@
+import { Tuple } from './types';
+
 /**
  * Builder class for providing variable overrides.
  * Supports type-safe methods for setting various Starlark-compatible types.
@@ -8,10 +10,10 @@ export class OverridesBuilder {
   /**
    * Sets a variable override with automatic type inference.
    * @param key - The variable name
-   * @param value - The value (string, number, boolean, array, or object)
+   * @param value - The value (string, number, boolean, array, Set, Tuple, or object)
    * @returns this for method chaining
    */
-  set(key: string, value: string | number | boolean | any[] | Record<string, any> | Map<any, any>): this {
+  set(key: string, value: string | number | boolean | any[] | Set<any> | Tuple | Record<string, any> | Map<any, any>): this {
     this.overrides.set(key, value);
     return this;
   }
@@ -66,6 +68,28 @@ export class OverridesBuilder {
     return this.set(key, value);
   }
 
+  /**
+   * Sets a tuple variable override.
+   * In Starlark, tuples are immutable sequences written as (item1, item2, ...).
+   * @param key - The variable name
+   * @param value - Tuple value
+   * @returns this for method chaining
+   */
+  setTuple(key: string, value: Tuple): this {
+    return this.set(key, value);
+  }
+
+  /**
+   * Sets a set variable override.
+   * In Starlark, sets use the set() builtin function: set([item1, item2, ...]).
+   * @param key - The variable name
+   * @param value - Set value
+   * @returns this for method chaining
+   */
+  setSet(key: string, value: Set<any>): this {
+    return this.set(key, value);
+  }
+
   /**
    * Gets all variable overrides.
    * @returns A copy of the overrides map

mbt/lib/typescript/src/types.ts

@@ -33,3 +33,19 @@ export class MbtError extends Error {
     this.name = 'MbtError';
   }
 }
+
+/**
+ * Represents a tuple (immutable sequence) for use in overrides.
+ * In Starlark, tuples are written as (item1, item2, ...).
+ */
+export class Tuple {
+  readonly items: any[];
+
+  constructor(...items: any[]) {
+    this.items = items;
+  }
+
+  static from(items: any[]): Tuple {
+    return new Tuple(...items);
+  }
+}

mbt/lib/typescript/src/value.ts

@@ -4,6 +4,7 @@
 
 import * as pb from '../proto-gen/mbt_plugin_pb';
 import { Ignored } from './sentinels';
+import { Tuple } from './types';
 
 /**
  * Converts a protobuf Value to a native TypeScript value.
@@ -94,6 +95,24 @@ export function toProtoValue(value: any): pb.Value {
     return result;
   }
 
+  // Handle Tuple instances (must come before Array check)
+  if (value instanceof Tuple) {
+    const tupleValue = new pb.TupleValue();
+    const items = value.items.map(item => toProtoValue(item));
+    tupleValue.setItemsList(items);
+    result.setTupleValue(tupleValue);
+    return result;
+  }
+
+  // Handle Set instances
+  if (value instanceof Set) {
+    const setValue = new pb.SetValue();
+    const items = Array.from(value).map(item => toProtoValue(item));
+    setValue.setItemsList(items);
+    result.setSetValue(setValue);
+    return result;
+  }
+
   if (Array.isArray(value)) {
     const listValue = new pb.ListValue();
     const items = value.map(item => toProtoValue(item));