[torque] Simplify and cleanup Cast and UnsafeCast

Change-Id: I57e21c5bc754ca07f52032f85ec8aeff96448dd0
Reviewed-on: https://chromium-review.googlesource.com/c/1342929
Commit-Queue: Daniel Clifford <danno@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#57855}

src/builtins/array-foreach.tq

@@ -115,7 +115,7 @@ namespace array {
       const a: JSArray = Cast<JSArray>(o) otherwise Slow;
       const map: Map = a.map;
 
-      if (!IsPrototypeInitialArrayPrototype(context, map)) goto Slow;
+      if (!IsPrototypeInitialArrayPrototype(map)) goto Slow;
       const elementsKind: ElementsKind = map.elements_kind;
       if (!IsFastElementsKind(elementsKind)) goto Slow;
 

src/builtins/array-join.tq

@@ -323,7 +323,7 @@ namespace array {
     try {
       const array: JSArray = Cast<JSArray>(receiver) otherwise IfSlowPath;
       if (array.length != lenNumber) goto IfSlowPath;
-      if (!IsPrototypeInitialArrayPrototype(context, map)) goto IfSlowPath;
+      if (!IsPrototypeInitialArrayPrototype(map)) goto IfSlowPath;
       if (IsNoElementsProtectorCellInvalid()) goto IfSlowPath;
 
       if (IsElementsKindLessThanOrEqual(kind, HOLEY_ELEMENTS)) {

src/builtins/array-lastindexof.tq

@@ -7,7 +7,8 @@ namespace array {
       elements: FixedArrayBase, index: Smi): Object
       labels IfHole;
 
-  LoadWithHoleCheck<FixedArray>(elements: FixedArrayBase, index: Smi): Object
+  LoadWithHoleCheck<FixedArray>(implicit context: Context)(
+      elements: FixedArrayBase, index: Smi): Object
       labels IfHole {
     const elements: FixedArray = UnsafeCast<FixedArray>(elements);
     const element: Object = elements[index];
@@ -15,8 +16,8 @@ namespace array {
     return element;
   }
 
-  LoadWithHoleCheck<FixedDoubleArray>(elements: FixedArrayBase, index: Smi):
-      Object
+  LoadWithHoleCheck<FixedDoubleArray>(implicit context: Context)(
+      elements: FixedArrayBase, index: Smi): Object
       labels IfHole {
     const elements: FixedDoubleArray = UnsafeCast<FixedDoubleArray>(elements);
     const element: float64 = LoadDoubleWithHoleCheck(elements, index)
@@ -44,7 +45,7 @@ namespace array {
 
         const same: Boolean = StrictEqual(searchElement, element);
         if (same == True) {
-          assert(IsFastJSArray(array, context));
+          assert(Is<FastJSArray>(array));
           return k;
         }
       }
@@ -53,7 +54,7 @@ namespace array {
       --k;
     }
 
-    assert(IsFastJSArray(array, context));
+    assert(Is<FastJSArray>(array));
     return -1;
   }
 

src/builtins/array-reverse.tq

@@ -6,19 +6,19 @@ namespace array {
   macro LoadElement<ElementsAccessor: type, T: type>(
       elements: FixedArrayBase, index: Smi): T;
 
-  LoadElement<FastPackedSmiElements, Smi>(elements: FixedArrayBase, index: Smi):
-      Smi {
+  LoadElement<FastPackedSmiElements, Smi>(implicit context: Context)(
+      elements: FixedArrayBase, index: Smi): Smi {
     const elems: FixedArray = UnsafeCast<FixedArray>(elements);
     return UnsafeCast<Smi>(elems[index]);
   }
 
-  LoadElement<FastPackedObjectElements, Object>(
+  LoadElement<FastPackedObjectElements, Object>(implicit context: Context)(
       elements: FixedArrayBase, index: Smi): Object {
     const elems: FixedArray = UnsafeCast<FixedArray>(elements);
     return elems[index];
   }
 
-  LoadElement<FastPackedDoubleElements, float64>(
+  LoadElement<FastPackedDoubleElements, float64>(implicit context: Context)(
       elements: FixedArrayBase, index: Smi): float64 {
     try {
       const elems: FixedDoubleArray = UnsafeCast<FixedDoubleArray>(elements);
@@ -32,21 +32,22 @@ namespace array {
   }
 
   macro StoreElement<ElementsAccessor: type, T: type>(
-      elements: FixedArrayBase, index: Smi, value: T);
+      implicit context:
+          Context)(elements: FixedArrayBase, index: Smi, value: T);
 
-  StoreElement<FastPackedSmiElements, Smi>(
+  StoreElement<FastPackedSmiElements, Smi>(implicit context: Context)(
       elements: FixedArrayBase, index: Smi, value: Smi) {
     const elems: FixedArray = UnsafeCast<FixedArray>(elements);
     StoreFixedArrayElementSmi(elems, index, value, SKIP_WRITE_BARRIER);
   }
 
-  StoreElement<FastPackedObjectElements, Object>(
+  StoreElement<FastPackedObjectElements, Object>(implicit context: Context)(
       elements: FixedArrayBase, index: Smi, value: Object) {
     const elems: FixedArray = UnsafeCast<FixedArray>(elements);
     elems[index] = value;
   }
 
-  StoreElement<FastPackedDoubleElements, float64>(
+  StoreElement<FastPackedDoubleElements, float64>(implicit context: Context)(
       elements: FixedArrayBase, index: Smi, value: float64) {
     const elems: FixedDoubleArray = UnsafeCast<FixedDoubleArray>(elements);
     StoreFixedDoubleArrayElementWithSmiIndex(elems, index, value);
@@ -56,7 +57,7 @@ namespace array {
   // whether a property is present, so we can simply swap them using fast
   // FixedArray loads/stores.
   macro FastPackedArrayReverse<Accessor: type, T: type>(
-      elements: FixedArrayBase, length: Smi) {
+      implicit context: Context)(elements: FixedArrayBase, length: Smi) {
     let lower: Smi = 0;
     let upper: Smi = length - 1;
 

src/builtins/array-splice.tq

@@ -11,14 +11,14 @@ namespace array {
       elements: FixedArrayBase, first: Smi, count: Smi,
       capacity: Smi): FixedArrayType;
 
-  Extract<FixedArray>(
+  Extract<FixedArray>(implicit context: Context)(
       elements: FixedArrayBase, first: Smi, count: Smi,
       capacity: Smi): FixedArray {
     return UnsafeCast<FixedArray>(
         ExtractFixedArray(elements, first, count, capacity));
   }
 
-  Extract<FixedDoubleArray>(
+  Extract<FixedDoubleArray>(implicit context: Context)(
       elements: FixedArrayBase, first: Smi, count: Smi,
       capacity: Smi): FixedDoubleArray {
     if (elements == kEmptyFixedArray) {
@@ -51,7 +51,8 @@ namespace array {
         Convert<intptr>(srcIndex), Convert<intptr>(count));
   }
 
-  macro FastSplice<FixedArrayType: type, ElementType: type>(
+  macro FastSplice<FixedArrayType: type, ElementType: type>(implicit context:
+                                                                  Context)(
       args: constexpr Arguments, a: JSArray, length: Smi, newLength: Smi,
       lengthDelta: Smi, actualStart: Smi, insertCount: Smi,
       actualDeleteCount: Smi): void labels Bailout {
@@ -121,7 +122,7 @@ namespace array {
     const a: JSArray = Cast<JSArray>(o) otherwise Bailout;
 
     const map: Map = a.map;
-    if (!IsPrototypeInitialArrayPrototype(context, map)) goto Bailout;
+    if (!IsPrototypeInitialArrayPrototype(map)) goto Bailout;
     if (IsNoElementsProtectorCellInvalid()) goto Bailout;
     if (IsArraySpeciesProtectorCellInvalid()) goto Bailout;
 

src/builtins/array.tq

@@ -14,7 +14,7 @@ namespace array {
   type FastDoubleElements;
   type DictionaryElements;
 
-  macro EnsureWriteableFastElements(array: JSArray) {
+  macro EnsureWriteableFastElements(implicit context: Context)(array: JSArray) {
     assert(IsFastElementsKind(array.map.elements_kind));
 
     const elements: FixedArrayBase = array.elements;
@@ -30,7 +30,7 @@ namespace array {
     assert(array.elements.map != kCOWMap);
   }
 
-  macro IsJSArray(o: Object): bool {
+  macro IsJSArray(implicit context: Context)(o: Object): bool {
     try {
       const array: JSArray = Cast<JSArray>(o) otherwise NotArray;
       return true;

src/builtins/base.tq

@@ -522,59 +522,167 @@ extern macro TaggedToNumber(Object): Number
 
 macro CastHeapObject<A: type>(o: HeapObject): A
     labels CastError;
+
 CastHeapObject<HeapObject>(o: HeapObject): HeapObject
     labels CastError {
   return o;
 }
+
 CastHeapObject<FixedArray>(o: HeapObject): FixedArray
     labels CastError {
   return HeapObjectToFixedArray(o) otherwise CastError;
 }
+
 CastHeapObject<FixedDoubleArray>(o: HeapObject): FixedDoubleArray
     labels CastError {
   return HeapObjectToFixedDoubleArray(o) otherwise CastError;
 }
+
 CastHeapObject<SloppyArgumentsElements>(o: HeapObject): SloppyArgumentsElements
     labels CastError {
   return HeapObjectToSloppyArgumentsElements(o) otherwise CastError;
 }
+
 CastHeapObject<JSDataView>(o: HeapObject): JSDataView
     labels CastError {
   return HeapObjectToJSDataView(o) otherwise CastError;
 }
+
 CastHeapObject<Callable>(o: HeapObject): Callable
     labels CastError {
   return HeapObjectToCallable(o) otherwise CastError;
 }
+
 CastHeapObject<JSArray>(o: HeapObject): JSArray
     labels CastError {
   return HeapObjectToJSArray(o) otherwise CastError;
 }
+
+CastHeapObject<Context>(o: HeapObject): Context
+    labels CastError {
+  if (IsContext(o)) return %RawCast<Context>(o);
+  goto CastError;
+}
+
+CastHeapObject<JSObject>(o: HeapObject): JSObject
+    labels CastError {
+  if (IsJSObject(o)) return %RawCast<JSObject>(o);
+  goto CastError;
+}
+
+CastHeapObject<NumberDictionary>(o: HeapObject): NumberDictionary
+    labels CastError {
+  if (IsNumberDictionary(o)) return %RawCast<NumberDictionary>(o);
+  goto CastError;
+}
+
+CastHeapObject<FixedTypedArrayBase>(o: HeapObject): FixedTypedArrayBase
+    labels CastError {
+  if (IsFixedTypedArray(o)) return %RawCast<FixedTypedArrayBase>(o);
+  goto CastError;
+}
+
 CastHeapObject<String>(o: HeapObject): String
     labels CastError {
   return HeapObjectToString(o) otherwise CastError;
 }
+
 CastHeapObject<Constructor>(o: HeapObject): Constructor
     labels CastError {
   return HeapObjectToConstructor(o) otherwise CastError;
 }
 
-macro Cast<A: type>(o: HeapObject): A
+CastHeapObject<HeapNumber>(o: HeapObject): HeapNumber
+    labels CastError {
+  if (IsHeapNumber(o)) return %RawCast<HeapNumber>(o);
+  goto CastError;
+}
+
+CastHeapObject<Map>(implicit context: Context)(o: HeapObject): Map
+    labels CastError {
+  if (IsMap(o)) return %RawCast<Map>(o);
+  goto CastError;
+}
+
+CastHeapObject<JSArgumentsObjectWithLength>(implicit context: Context)(
+    o: HeapObject): JSArgumentsObjectWithLength
+    labels CastError {
+  const map: Map = o.map;
+  try {
+    if (IsFastAliasedArgumentsMap(map)) goto True;
+    if (IsSloppyArgumentsMap(map)) goto True;
+    if (IsStrictArgumentsMap(map)) goto True;
+    if (IsSlowAliasedArgumentsMap(map)) goto True;
+    goto CastError;
+  }
+  label True {
+    return %RawCast<JSArgumentsObjectWithLength>(o);
+  }
+}
+
+CastHeapObject<FastJSArray>(implicit context: Context)(o: HeapObject):
+    FastJSArray
+    labels CastError {
+  const map: Map = o.map;
+  if (!IsJSArrayMap(map)) goto CastError;
+
+  // Bailout if receiver has slow elements.
+  const elementsKind: ElementsKind = LoadMapElementsKind(map);
+  if (!IsFastElementsKind(elementsKind)) goto CastError;
+
+  // Verify that our prototype is the initial array prototype.
+  if (!IsPrototypeInitialArrayPrototype(map)) goto CastError;
+
+  if (IsNoElementsProtectorCellInvalid()) goto CastError;
+  return %RawCast<FastJSArray>(o);
+}
+
+CastHeapObject<FastJSArrayForCopy>(implicit context: Context)(o: HeapObject):
+    FastJSArrayForCopy
+    labels CastError {
+  if (IsArraySpeciesProtectorCellInvalid()) goto CastError;
+  const a: FastJSArray = Cast<FastJSArray>(o) otherwise CastError;
+  return %RawCast<FastJSArrayForCopy>(o);
+}
+
+CastHeapObject<FastJSArrayWithNoCustomIteration>(implicit context: Context)(
+    o: HeapObject): FastJSArrayWithNoCustomIteration
+    labels CastError {
+  if (IsArrayIteratorProtectorCellInvalid()) goto CastError;
+  const a: FastJSArray = Cast<FastJSArray>(o) otherwise CastError;
+  return %RawCast<FastJSArrayWithNoCustomIteration>(o);
+}
+
+CastHeapObject<JSReceiver>(implicit context: Context)(o: HeapObject): JSReceiver
+    labels CastError {
+  if (IsJSReceiver(o)) return %RawCast<JSReceiver>(o);
+  goto CastError;
+}
+
+CastHeapObject<JSFunction>(implicit context: Context)(o: HeapObject): JSFunction
+    labels CastError {
+  if (IsJSFunction(o)) return %RawCast<JSFunction>(o);
+  goto CastError;
+}
+
+macro Cast<A: type>(implicit context: Context)(o: HeapObject): A
     labels CastError {
   return CastHeapObject<A>(o) otherwise CastError;
 }
 
 // CastHeapObject allows this default-implementation to be non-recursive.
 // Otherwise the generated CSA code might run into infinite recursion.
-macro Cast<A: type>(o: Object): A
+macro Cast<A: type>(implicit context: Context)(o: Object): A
     labels CastError {
   return CastHeapObject<A>(TaggedToHeapObject(o) otherwise CastError)
       otherwise CastError;
 }
+
 Cast<Smi>(o: Object): Smi
     labels CastError {
   return TaggedToSmi(o) otherwise CastError;
 }
+
 Cast<Number>(o: Object): Number
     labels CastError {
   return TaggedToNumber(o) otherwise CastError;
@@ -774,218 +882,39 @@ Convert<intptr>(r: RawPtr): intptr {
   return Signed(r);
 }
 
-extern macro UnsafeCastNumberToHeapNumber(Number): HeapNumber;
-extern macro UnsafeCastObjectToFixedArrayBase(Object): FixedArrayBase;
-extern macro UnsafeCastObjectToFixedArray(Object): FixedArray;
-extern macro UnsafeCastObjectToContext(Object): Context;
-extern macro UnsafeCastObjectToFixedDoubleArray(Object): FixedDoubleArray;
-extern macro UnsafeCastObjectToHeapNumber(Object): HeapNumber;
-extern macro UnsafeCastObjectToCallable(Object): Callable;
-extern macro UnsafeCastObjectToSmi(Object): Smi;
-extern macro UnsafeCastObjectToNumber(Object): Number;
-extern macro UnsafeCastObjectToHeapObject(Object): HeapObject;
-extern macro UnsafeCastObjectToJSArray(Object): JSArray;
-extern macro UnsafeCastObjectToFixedTypedArrayBase(Object): FixedTypedArrayBase;
-extern macro UnsafeCastObjectToNumberDictionary(Object): NumberDictionary;
-extern macro UnsafeCastObjectToJSReceiver(Object): JSReceiver;
-extern macro UnsafeCastObjectToJSObject(Object): JSObject;
-extern macro UnsafeCastObjectToMap(Object): Map;
-extern macro UnsafeCastObjectToString(Object): String;
-
-macro UnsafeCast<A: type>(n: Number): A;
-UnsafeCast<HeapNumber>(n: Number): HeapNumber {
-  return UnsafeCastNumberToHeapNumber(n);
-}
-UnsafeCast<Smi>(o: Number): Smi {
-  return UnsafeCastObjectToSmi(o);
-}
-macro UnsafeCast<A: type>(o: Object): A;
-UnsafeCast<Object>(o: Object): Object {
-  return o;
-}
-UnsafeCast<FixedArray>(o: Object): FixedArray {
-  return UnsafeCastObjectToFixedArray(o);
-}
-UnsafeCast<FixedDoubleArray>(o: Object): FixedDoubleArray {
-  return UnsafeCastObjectToFixedDoubleArray(o);
-}
-UnsafeCast<HeapNumber>(o: Object): HeapNumber {
-  return UnsafeCastObjectToHeapNumber(o);
-}
-UnsafeCast<Callable>(o: Object): Callable {
-  return UnsafeCastObjectToCallable(o);
-}
-UnsafeCast<Smi>(o: Object): Smi {
-  return UnsafeCastObjectToSmi(o);
-}
-UnsafeCast<Number>(o: Object): Number {
-  return UnsafeCastObjectToNumber(o);
-}
-UnsafeCast<HeapObject>(o: Object): HeapObject {
-  return UnsafeCastObjectToHeapObject(o);
-}
-UnsafeCast<JSArray>(o: Object): JSArray {
-  return UnsafeCastObjectToJSArray(o);
-}
-UnsafeCast<FixedTypedArrayBase>(o: Object): FixedTypedArrayBase {
-  return UnsafeCastObjectToFixedTypedArrayBase(o);
-}
-UnsafeCast<NumberDictionary>(o: Object): NumberDictionary {
-  return UnsafeCastObjectToNumberDictionary(o);
-}
-UnsafeCast<JSReceiver>(o: Object): JSReceiver {
-  return UnsafeCastObjectToJSReceiver(o);
-}
-UnsafeCast<JSObject>(o: Object): JSObject {
-  return UnsafeCastObjectToJSObject(o);
-}
-UnsafeCast<Map>(o: Object): Map {
-  return UnsafeCastObjectToMap(o);
-}
-UnsafeCast<FixedArrayBase>(o: Object): FixedArrayBase {
-  return UnsafeCastObjectToFixedArrayBase(o);
-}
-UnsafeCast<Context>(o: Object): Context {
-  return UnsafeCastObjectToContext(o);
-}
-UnsafeCast<String>(o: Object): String {
-  return UnsafeCastObjectToString(o);
-}
-
-macro BranchIfJSArgumentsObjectWithLength(implicit context: Context)(o: Object):
-    never
+macro BranchIf<A: type, B: type>(implicit context: Context)(o: B): never
     labels True, False {
-  const heapObject: HeapObject = Cast<HeapObject>(o) otherwise False;
-  const map: Map = heapObject.map;
-  if (IsFastAliasedArgumentsMap(map)) goto True;
-  if (IsSloppyArgumentsMap(map)) goto True;
-  if (IsStrictArgumentsMap(map)) goto True;
-  if (!IsSlowAliasedArgumentsMap(map)) goto False;
+  Cast<A>(o) otherwise False;
   goto True;
 }
 
-UnsafeCast<JSArgumentsObjectWithLength>(implicit context: Context)(o: Object):
-    JSArgumentsObjectWithLength {
-  assert(BranchIfJSArgumentsObjectWithLength(o));
-  return %RawCast<JSArgumentsObjectWithLength>(o);
-}
-
-Cast<JSArgumentsObjectWithLength>(implicit context: Context)(o: Object):
-    JSArgumentsObjectWithLength
-    labels CastError {
-  if (BranchIfJSArgumentsObjectWithLength(o)) {
-    return UnsafeCast<JSArgumentsObjectWithLength>(o);
-  } else {
-    goto CastError;
-  }
-}
-
-UnsafeCast<FastJSArray>(implicit context: Context)(o: Object): FastJSArray {
-  assert(BranchIfFastJSArray(o, context));
-  return %RawCast<FastJSArray>(o);
-}
-
-Cast<FastJSArray>(implicit context: Context)(o: Object): FastJSArray
-    labels CastError {
-  if (BranchIfFastJSArray(o, context)) {
-    return UnsafeCast<FastJSArray>(o);
-  } else {
-    goto CastError;
-  }
-}
-
-Cast<FastJSArray>(implicit context: Context)(ho: HeapObject): FastJSArray
-    labels CastError {
-  if (BranchIfFastJSArray(ho, context)) {
-    return UnsafeCast<FastJSArray>(ho);
-  } else {
-    goto CastError;
-  }
-}
-
-UnsafeCast<FastJSArrayForCopy>(implicit context: Context)(o: Object):
-    FastJSArrayForCopy {
-  assert(BranchIfFastJSArrayForCopy(o, context));
-  return %RawCast<FastJSArrayForCopy>(o);
-}
-
-Cast<FastJSArrayForCopy>(implicit context: Context)(o: Object):
-    FastJSArrayForCopy
-    labels CastError {
-  if (BranchIfFastJSArrayForCopy(o, context)) {
-    return UnsafeCast<FastJSArrayForCopy>(o);
-  } else {
-    goto CastError;
-  }
-}
-
-UnsafeCast<FastJSArrayWithNoCustomIteration>(implicit context: Context)(
-    o: Object): FastJSArrayWithNoCustomIteration {
-  assert(BranchIfFastJSArrayWithNoCustomIteration(o));
-  return %RawCast<FastJSArrayWithNoCustomIteration>(o);
-}
-
-Cast<FastJSArrayWithNoCustomIteration>(implicit context: Context)(o: Object):
-    FastJSArrayWithNoCustomIteration labels CastError {
-  if (BranchIfFastJSArrayWithNoCustomIteration(o)) {
-    return UnsafeCast<FastJSArrayWithNoCustomIteration>(o);
-  } else {
-    goto CastError;
-  }
-}
-
-UnsafeCast<JSFunction>(implicit context: Context)(o: Object): JSFunction {
-  assert(IsJSFunction(Cast<HeapObject>(o) otherwise unreachable));
-  return %RawCast<JSFunction>(o);
+macro BranchIfNot<A: type, B: type>(implicit context: Context)(o: B): never
+    labels True, False {
+  Cast<A>(o) otherwise True;
+  goto False;
 }
 
-Cast<JSFunction>(implicit context: Context)(o: Object): JSFunction
-    labels CastError {
-  if (IsJSFunction(Cast<HeapObject>(o) otherwise CastError)) {
-    return UnsafeCast<JSFunction>(o);
-  } else {
-    goto CastError;
-  }
+macro Is<A: type, B: type>(implicit context: Context)(o: B): bool {
+  return (BranchIf<A, B>(o)) ? true : false;
 }
 
-Cast<Map>(o: Object): Map
-    labels CastError {
-  if (IsMap(Cast<HeapObject>(o) otherwise CastError)) {
-    return UnsafeCast<Map>(o);
-  } else {
-    goto CastError;
-  }
+macro UnsafeCast<A: type>(implicit context: Context)(o: Object): A {
+  assert(Is<A>(o));
+  return %RawCast<A>(o);
 }
 
-Cast<JSReceiver>(o: Object): JSReceiver
-    labels CastError {
-  if (IsJSReceiver(Cast<HeapObject>(o) otherwise CastError)) {
-    return UnsafeCast<JSReceiver>(o);
-  } else {
-    goto CastError;
-  }
+UnsafeCast<Object>(o: Object): Object {
+  return o;
 }
 
-const kCOWMap: Map = UnsafeCast<Map>(LoadRoot(kFixedCOWArrayMapRootIndex));
+const kCOWMap: Map = %RawCast<Map>(LoadRoot(kFixedCOWArrayMapRootIndex));
 const kEmptyFixedArray: FixedArrayBase =
-    UnsafeCast<FixedArrayBase>(LoadRoot(kEmptyFixedArrayRootIndex));
+    %RawCast<FixedArrayBase>(LoadRoot(kEmptyFixedArrayRootIndex));
 
-extern macro BranchIfFastJSArray(Object, Context): never
-    labels Taken, NotTaken;
-extern macro BranchIfFastJSArrayForCopy(Object, Context): never
-    labels Taken, NotTaken;
-extern macro BranchIfFastJSArrayWithNoCustomIteration(
-    implicit context: Context)(Object): never labels Taken,
-    NotTaken;
-extern macro BranchIfNotFastJSArray(Object, Context): never
-    labels Taken, NotTaken;
-macro BranchIfNotFastJSArrayForCopy(implicit context: Context)(o: Object): never
-    labels Taken, NotTaken {
-  BranchIfFastJSArrayForCopy(o, context) otherwise NotTaken, Taken;
-}
-
-extern macro IsPrototypeInitialArrayPrototype(Context, Map): bool;
+extern macro IsPrototypeInitialArrayPrototype(implicit context: Context)(Map):
+    bool;
 extern macro IsNoElementsProtectorCellInvalid(): bool;
+extern macro IsArrayIteratorProtectorCellInvalid(): bool;
 extern macro IsArraySpeciesProtectorCellInvalid(): bool;
 extern macro IsTypedArraySpeciesProtectorCellInvalid(): bool;
 extern macro IsPromiseSpeciesProtectorCellInvalid(): bool;
@@ -1176,7 +1105,8 @@ macro TorqueCopyElements(
 transitioning macro LoadElementNoHole<T: type>(a: JSArray, index: Smi): Object
     labels IfHole;
 
-LoadElementNoHole<FixedArray>(a: JSArray, index: Smi): Object
+LoadElementNoHole<FixedArray>(implicit context: Context)(
+    a: JSArray, index: Smi): Object
     labels IfHole {
   try {
     let elements: FixedArray =
@@ -1192,7 +1122,8 @@ LoadElementNoHole<FixedArray>(a: JSArray, index: Smi): Object
   }
 }
 
-LoadElementNoHole<FixedDoubleArray>(a: JSArray, index: Smi): Object
+LoadElementNoHole<FixedDoubleArray>(implicit context: Context)(
+    a: JSArray, index: Smi): Object
     labels IfHole {
   try {
     let elements: FixedDoubleArray =
@@ -1212,31 +1143,24 @@ extern macro IsCallable(HeapObject): bool;
 extern macro IsJSArray(HeapObject): bool;
 extern macro IsMap(HeapObject): bool;
 extern macro IsJSFunction(HeapObject): bool;
+extern macro IsJSObject(HeapObject): bool;
+extern macro IsNumberDictionary(HeapObject): bool;
+extern macro IsFixedTypedArray(HeapObject): bool;
+extern macro IsContext(HeapObject): bool;
 extern macro IsJSReceiver(HeapObject): bool;
 extern macro TaggedIsCallable(Object): bool;
 extern macro IsDetachedBuffer(JSArrayBuffer): bool;
 extern macro IsHeapNumber(HeapObject): bool;
 extern macro IsFixedArray(HeapObject): bool;
 extern macro IsNumber(Object): bool;
+extern macro IsJSArrayMap(Map): bool;
 extern macro IsExtensibleMap(Map): bool;
 extern macro IsCustomElementsReceiverInstanceType(int32): bool;
-extern macro IsFastJSArray(Object, Context): bool;
 extern macro IsFastJSArrayWithNoCustomIteration(implicit context: Context)(
     Object): bool;
 extern macro Typeof(Object): Object;
 extern macro LoadTargetFromFrame(): JSFunction;
 
-macro IsJSReceiver(o: Object): bool {
-  typeswitch (o) {
-    case (JSReceiver): {
-      return true;
-    }
-    case (Object): {
-      return false;
-    }
-  }
-}
-
 // Return true iff number is NaN.
 macro NumberIsNaN(number: Number): bool {
   typeswitch (number) {
@@ -1250,6 +1174,7 @@ macro NumberIsNaN(number: Number): bool {
   }
 }
 
+extern macro GotoIfForceSlowPath() labels Taken;
 extern macro BranchIfToBooleanIsTrue(Object): never
     labels Taken, NotTaken;
 
@@ -1311,3 +1236,43 @@ struct KeyValuePair {
   key: Object;
   value: Object;
 }
+
+// Macro definitions for compatibility that expose functionality to the CSA
+// using "legacy" APIs. In Torque code, these should not be used.
+macro IsFastJSArray(o: Object, context: Context): bool {
+  try {
+    // Long-term, it's likely not a good idea to have this slow-path test here,
+    // since it fundamentally breaks the type system.
+    GotoIfForceSlowPath() otherwise ForceSlow;
+  }
+  label ForceSlow {
+    return false;
+  }
+
+  return Is<FastJSArray>(o);
+}
+
+macro BranchIfFastJSArray(o: Object, context: Context): never
+    labels True, False {
+  // Long-term, it's likely not a good idea to have this slow-path test here,
+  // since it fundamentally breaks the type system.
+  GotoIfForceSlowPath() otherwise False;
+  BranchIf<FastJSArray>(o) otherwise True, False;
+}
+
+macro BranchIfNotFastJSArray(o: Object, context: Context): never
+    labels True, False {
+  BranchIfNot<FastJSArray>(o) otherwise True, False;
+}
+
+macro BranchIfFastJSArrayForCopy(o: Object, context: Context): never
+    labels True, False {
+  // Long-term, it's likely not a good idea to have this slow-path test here,
+  // since it fundamentally breaks the type system.
+  GotoIfForceSlowPath() otherwise False;
+  BranchIf<FastJSArrayForCopy>(o) otherwise True, False;
+}
+
+macro IsFastJSArrayWithNoCustomIteration(context: Context, o: Object): bool {
+  return Is<FastJSArrayWithNoCustomIteration>(o);
+}

src/builtins/builtins-array-gen.cc

@@ -148,7 +148,7 @@ Node* ArrayBuiltinsAssembler::FindProcessor(Node* k_value, Node* k) {
       Label fast(this);
       Label runtime(this);
       Label object_push_pre(this), object_push(this), double_push(this);
-      BranchIfFastJSArray(a(), context(), &fast, &runtime);
+      BranchIfFastJSArray(CAST(a()), context(), &fast, &runtime);
 
       BIND(&fast);
       {

src/builtins/object-fromentries.tq

@@ -21,7 +21,7 @@ namespace object {
           // Bail out if ToPropertyKey will attempt to load and call
           // Symbol.toPrimitive, toString, and valueOf, which could
           // invalidate assumptions about the iterable.
-          if (IsJSReceiver(pair.key)) goto IfSlow;
+          if (Is<JSReceiver>(pair.key)) goto IfSlow;
           CreateDataProperty(result, pair.key, pair.value);
         }
         return result;

src/builtins/typed-array.tq

@@ -16,6 +16,18 @@ namespace typed_array {
   type LoadFn = builtin(Context, JSTypedArray, Smi) => Object;
   type StoreFn = builtin(Context, JSTypedArray, Smi, Object) => Object;
 
+  // These UnsafeCast specializations are necessary becuase there is no
+  // way to definitively test whether an Object is a Torque function
+  // with a specific signature, and the default UnsafeCast implementation
+  // would try to check this through an assert(Is<>), so the test
+  // is bypassed in this specialization.
+  UnsafeCast<LoadFn>(implicit context: Context)(o: Object): LoadFn {
+    return %RawCast<LoadFn>(o);
+  }
+  UnsafeCast<StoreFn>(implicit context: Context)(o: Object): StoreFn {
+    return %RawCast<StoreFn>(o);
+  }
+
   macro KindForArrayType<T: type>(): constexpr ElementsKind;
   KindForArrayType<FixedUint8Array>(): constexpr ElementsKind {
     return UINT8_ELEMENTS;

src/code-stub-assembler.cc

@@ -1037,90 +1037,6 @@ void CodeStubAssembler::BranchIfJSReceiver(Node* object, Label* if_true,
   Branch(IsJSReceiver(object), if_true, if_false);
 }
 
-TNode<BoolT> CodeStubAssembler::IsFastJSArray(SloppyTNode<Object> object,
-                                              SloppyTNode<Context> context) {
-  Label if_true(this), if_false(this, Label::kDeferred), exit(this);
-  BranchIfFastJSArray(object, context, &if_true, &if_false);
-  TVARIABLE(BoolT, var_result);
-  BIND(&if_true);
-  {
-    var_result = Int32TrueConstant();
-    Goto(&exit);
-  }
-  BIND(&if_false);
-  {
-    var_result = Int32FalseConstant();
-    Goto(&exit);
-  }
-  BIND(&exit);
-  return var_result.value();
-}
-
-void CodeStubAssembler::BranchIfFastJSArrayWithNoCustomIteration(
-    TNode<Context> context, TNode<Object> object, Label* if_true,
-    Label* if_false) {
-  Label if_fast(this);
-  BranchIfFastJSArray(object, context, &if_fast, if_false, true);
-  BIND(&if_fast);
-  {
-    // Check that the Array.prototype hasn't been modified in a way that would
-    // affect iteration.
-    Node* protector_cell = LoadRoot(RootIndex::kArrayIteratorProtector);
-    DCHECK(isolate()->heap()->array_iterator_protector()->IsPropertyCell());
-    Branch(
-        WordEqual(LoadObjectField(protector_cell, PropertyCell::kValueOffset),
-                  SmiConstant(Isolate::kProtectorValid)),
-        if_true, if_false);
-  }
-}
-
-TNode<BoolT> CodeStubAssembler::IsFastJSArrayWithNoCustomIteration(
-    TNode<Context> context, TNode<Object> object) {
-  Label if_false(this, Label::kDeferred), exit(this);
-  TVARIABLE(BoolT, var_result, Int32TrueConstant());
-  BranchIfFastJSArrayWithNoCustomIteration(context, object, &exit, &if_false);
-  BIND(&if_false);
-  {
-    var_result = Int32FalseConstant();
-    Goto(&exit);
-  }
-  BIND(&exit);
-  return var_result.value();
-}
-
-void CodeStubAssembler::BranchIfFastJSArray(Node* object, Node* context,
-                                            Label* if_true, Label* if_false,
-                                            bool iteration_only) {
-  GotoIfForceSlowPath(if_false);
-
-  // Bailout if receiver is a Smi.
-  GotoIf(TaggedIsSmi(object), if_false);
-
-  Node* map = LoadMap(object);
-  GotoIfNot(IsJSArrayMap(map), if_false);
-
-  // Bailout if receiver has slow elements.
-  Node* elements_kind = LoadMapElementsKind(map);
-  GotoIfNot(IsFastElementsKind(elements_kind), if_false);
-
-  // Verify that our prototype is the initial array prototype.
-  GotoIfNot(IsPrototypeInitialArrayPrototype(context, map), if_false);
-
-  if (iteration_only) {
-    // If we are only iterating over the array, there is no need to check
-    // the NoElements protector if the array is not holey.
-    GotoIfNot(IsHoleyFastElementsKind(elements_kind), if_true);
-  }
-  Branch(IsNoElementsProtectorCellInvalid(), if_false, if_true);
-}
-
-void CodeStubAssembler::BranchIfFastJSArrayForCopy(Node* object, Node* context,
-                                                   Label* if_true,
-                                                   Label* if_false) {
-  GotoIf(IsArraySpeciesProtectorCellInvalid(), if_false);
-  BranchIfFastJSArray(object, context, if_true, if_false);
-}
-
 void CodeStubAssembler::GotoIfForceSlowPath(Label* if_true) {
 #ifdef V8_ENABLE_FORCE_SLOW_PATH
   Node* const force_slow_path_addr =
@@ -5958,6 +5874,13 @@ TNode<BoolT> CodeStubAssembler::IsNoElementsProtectorCellInvalid() {
   return WordEqual(cell_value, invalid);
 }
 
+TNode<BoolT> CodeStubAssembler::IsArrayIteratorProtectorCellInvalid() {
+  Node* invalid = SmiConstant(Isolate::kProtectorInvalid);
+  Node* cell = LoadRoot(RootIndex::kArrayIteratorProtector);
+  Node* cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
+  return WordEqual(cell_value, invalid);
+}
+
 TNode<BoolT> CodeStubAssembler::IsPromiseResolveProtectorCellInvalid() {
   Node* invalid = SmiConstant(Isolate::kProtectorInvalid);
   Node* cell = LoadRoot(RootIndex::kPromiseResolveProtector);

src/code-stub-assembler.h

@@ -326,105 +326,6 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
     return CAST(heap_object);
   }
 
-  TNode<HeapNumber> UnsafeCastNumberToHeapNumber(TNode<Number> p_n) {
-    return CAST(p_n);
-  }
-
-  TNode<FixedArrayBase> UnsafeCastObjectToFixedArrayBase(TNode<Object> p_o) {
-    return CAST(p_o);
-  }
-
-  TNode<FixedArray> UnsafeCastObjectToFixedArray(TNode<Object> p_o) {
-    return CAST(p_o);
-  }
-
-  TNode<Context> UnsafeCastObjectToContext(TNode<Object> p_o) {
-    return CAST(p_o);
-  }
-
-  TNode<FixedDoubleArray> UnsafeCastObjectToFixedDoubleArray(
-      TNode<Object> p_o) {
-    return CAST(p_o);
-  }
-
-  TNode<HeapNumber> UnsafeCastObjectToHeapNumber(TNode<Object> p_o) {
-    return CAST(p_o);
-  }
-
-  TNode<HeapObject> UnsafeCastObjectToCallable(TNode<Object> p_o) {
-    return CAST(p_o);
-  }
-
-  TNode<Smi> UnsafeCastObjectToSmi(TNode<Object> p_o) { return CAST(p_o); }
-
-  TNode<Number> UnsafeCastObjectToNumber(TNode<Object> p_o) {
-    return CAST(p_o);
-  }
-
-  TNode<HeapObject> UnsafeCastObjectToHeapObject(TNode<Object> p_o) {
-    return CAST(p_o);
-  }
-
-  TNode<JSArray> UnsafeCastObjectToJSArray(TNode<Object> p_o) {
-    return CAST(p_o);
-  }
-
-  TNode<FixedTypedArrayBase> UnsafeCastObjectToFixedTypedArrayBase(
-      TNode<Object> p_o) {
-    return CAST(p_o);
-  }
-
-  TNode<Object> UnsafeCastObjectToCompareBuiltinFn(TNode<Object> p_o) {
-    return p_o;
-  }
-
-  TNode<Object> UnsafeCastObjectToLoadFn(TNode<Object> p_o) { return p_o; }
-  TNode<Object> UnsafeCastObjectToStoreFn(TNode<Object> p_o) { return p_o; }
-  TNode<Object> UnsafeCastObjectToCanUseSameAccessorFn(TNode<Object> p_o) {
-    return p_o;
-  }
-
-  TNode<NumberDictionary> UnsafeCastObjectToNumberDictionary(
-      TNode<Object> p_o) {
-    return CAST(p_o);
-  }
-
-  TNode<JSReceiver> UnsafeCastObjectToJSReceiver(TNode<Object> p_o) {
-    return CAST(p_o);
-  }
-
-  TNode<JSObject> UnsafeCastObjectToJSObject(TNode<Object> p_o) {
-    return CAST(p_o);
-  }
-
-  TNode<Map> UnsafeCastObjectToMap(TNode<Object> p_o) { return CAST(p_o); }
-
-  TNode<String> UnsafeCastObjectToString(TNode<Object> p_o) {
-    return CAST(p_o);
-  }
-
-  TNode<JSArgumentsObjectWithLength> RawCastObjectToJSArgumentsObjectWithLength(
-      TNode<Object> p_o) {
-    return TNode<JSArgumentsObjectWithLength>::UncheckedCast(p_o);
-  }
-
-  TNode<JSArray> RawCastObjectToFastJSArray(TNode<Object> p_o) {
-    return TNode<JSArray>::UncheckedCast(p_o);
-  }
-
-  TNode<JSArray> RawCastObjectToFastJSArrayForCopy(TNode<Object> p_o) {
-    return TNode<JSArray>::UncheckedCast(p_o);
-  }
-
-  TNode<JSArray> RawCastObjectToFastJSArrayWithNoCustomIteration(
-      TNode<Object> p_o) {
-    return TNode<JSArray>::UncheckedCast(p_o);
-  }
-
-  TNode<JSFunction> RawCastObjectToJSFunction(TNode<Object> p_o) {
-    return TNode<JSFunction>::UncheckedCast(p_o);
-  }
-
   Node* MatchesParameterMode(Node* value, ParameterMode mode);
 
 #define PARAMETER_BINOP(OpName, IntPtrOpName, SmiOpName) \
@@ -804,19 +705,6 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
 
   void BranchIfJSReceiver(Node* object, Label* if_true, Label* if_false);
 
-  void BranchIfFastJSArray(Node* object, Node* context, Label* if_true,
-                           Label* if_false, bool iteration_only = false);
-  void BranchIfNotFastJSArray(Node* object, Node* context, Label* if_true,
-                              Label* if_false) {
-    BranchIfFastJSArray(object, context, if_false, if_true);
-  }
-  void BranchIfFastJSArrayForCopy(Node* object, Node* context, Label* if_true,
-                                  Label* if_false);
-  void BranchIfFastJSArrayWithNoCustomIteration(TNode<Context> context,
-                                                TNode<Object> object,
-                                                Label* if_true,
-                                                Label* if_false);
-
   // Branches to {if_true} when --force-slow-path flag has been passed.
   // It's used for testing to ensure that slow path implementation behave
   // equivalent to corresponding fast paths (where applicable).
@@ -2022,6 +1910,7 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
   TNode<BoolT> IsAllocationSite(SloppyTNode<HeapObject> object);
   TNode<BoolT> IsAnyHeapNumber(SloppyTNode<HeapObject> object);
   TNode<BoolT> IsNoElementsProtectorCellInvalid();
+  TNode<BoolT> IsArrayIteratorProtectorCellInvalid();
   TNode<BoolT> IsBigIntInstanceType(SloppyTNode<Int32T> instance_type);
   TNode<BoolT> IsBigInt(SloppyTNode<HeapObject> object);
   TNode<BoolT> IsBoolean(SloppyTNode<HeapObject> object);
@@ -2039,10 +1928,6 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
   TNode<BoolT> IsExtensibleMap(SloppyTNode<Map> map);
   TNode<BoolT> IsExtensibleNonPrototypeMap(TNode<Map> map);
   TNode<BoolT> IsExternalStringInstanceType(SloppyTNode<Int32T> instance_type);
-  TNode<BoolT> IsFastJSArray(SloppyTNode<Object> object,
-                             SloppyTNode<Context> context);
-  TNode<BoolT> IsFastJSArrayWithNoCustomIteration(TNode<Context> context,
-                                                  TNode<Object> object);
   TNode<BoolT> IsFeedbackCell(SloppyTNode<HeapObject> object);
   TNode<BoolT> IsFeedbackVector(SloppyTNode<HeapObject> object);
   TNode<BoolT> IsContext(SloppyTNode<HeapObject> object);

test/cctest/torque/test-torque.cc

@@ -244,11 +244,15 @@ TEST(TestForLoop) {
 }
 
 TEST(TestTypeswitch) {
-  Isolate* isolate(CcTest::InitIsolateOnce());
+  CcTest::InitializeVM();
+  Isolate* isolate(CcTest::i_isolate());
+  i::HandleScope scope(isolate);
+  Handle<Context> context =
+      Utils::OpenHandle(*v8::Isolate::GetCurrent()->GetCurrentContext());
   CodeAssemblerTester asm_tester(isolate, 0);
   TestTorqueAssembler m(asm_tester.state());
   {
-    m.TestTypeswitch();
+    m.TestTypeswitch(m.UncheckedCast<Context>(m.HeapConstant(context)));
     m.Return(m.UndefinedConstant());
   }
   FunctionTester ft(asm_tester.GenerateCode(), 0);
@@ -256,11 +260,15 @@ TEST(TestTypeswitch) {
 }
 
 TEST(TestGenericOverload) {
-  Isolate* isolate(CcTest::InitIsolateOnce());
+  CcTest::InitializeVM();
+  Isolate* isolate(CcTest::i_isolate());
+  i::HandleScope scope(isolate);
+  Handle<Context> context =
+      Utils::OpenHandle(*v8::Isolate::GetCurrent()->GetCurrentContext());
   CodeAssemblerTester asm_tester(isolate, 0);
   TestTorqueAssembler m(asm_tester.state());
   {
-    m.TestGenericOverload();
+    m.TestGenericOverload(m.UncheckedCast<Context>(m.HeapConstant(context)));
     m.Return(m.UndefinedConstant());
   }
   FunctionTester ft(asm_tester.GenerateCode(), 0);
@@ -352,11 +360,15 @@ TEST(TestCatch3) {
 }
 
 TEST(TestLookup) {
-  Isolate* isolate(CcTest::InitIsolateOnce());
+  CcTest::InitializeVM();
+  Isolate* isolate(CcTest::i_isolate());
+  i::HandleScope scope(isolate);
+  Handle<Context> context =
+      Utils::OpenHandle(*v8::Isolate::GetCurrent()->GetCurrentContext());
   CodeAssemblerTester asm_tester(isolate, 0);
   TestTorqueAssembler m(asm_tester.state());
   {
-    m.TestQualifiedAccess();
+    m.TestQualifiedAccess(m.UncheckedCast<Context>(m.HeapConstant(context)));
     m.Return(m.UndefinedConstant());
   }
   FunctionTester ft(asm_tester.GenerateCode(), 0);

test/torque/test-torque.tq

@@ -174,7 +174,7 @@ namespace test {
     return x + 2;
   }
 
-  macro TestFunctionPointers(context: Context): Boolean {
+  macro TestFunctionPointers(implicit context: Context)(): Boolean {
     let fptr: builtin(Context, Smi) => Smi = TestHelperPlus1;
     check(fptr(context, 42) == 43);
     fptr = TestHelperPlus2;
@@ -182,7 +182,7 @@ namespace test {
     return True;
   }
 
-  macro TestVariableRedeclaration(context: Context): Boolean {
+  macro TestVariableRedeclaration(implicit context: Context)(): Boolean {
     let var1: int31 = FromConstexpr<bool>(42 == 0) ? 0 : 1;
     let var2: int31 = FromConstexpr<bool>(42 == 0) ? 1 : 0;
     return True;
@@ -208,11 +208,11 @@ namespace test {
     return x;
   }
 
-  macro TestUnsafeCast(c: Context, n: Number): Boolean {
+  macro TestUnsafeCast(implicit context: Context)(n: Number): Boolean {
     if (TaggedIsSmi(n)) {
       let m: Smi = UnsafeCast<Smi>(n);
 
-      check(TestHelperPlus1(c, m) == 11);
+      check(TestHelperPlus1(context, m) == 11);
       return True;
     }
     return False;
@@ -223,7 +223,7 @@ namespace test {
     check(Convert<intptr>(-0xffff) == -65535);
   }
 
-  macro TestLargeIntegerLiterals(c: Context) {
+  macro TestLargeIntegerLiterals(implicit c: Context)() {
     let x: int32 = 0x40000000;
     let y: int32 = 0x7fffffff;
   }
@@ -278,11 +278,11 @@ namespace test {
     return i.i;
   }
 
-  macro TestStruct2(): TestStructA {
+  macro TestStruct2(implicit context: Context)(): TestStructA {
     return TestStructA{UnsafeCast<FixedArray>(kEmptyFixedArray), 27, 31};
   }
 
-  macro TestStruct3(): TestStructA {
+  macro TestStruct3(implicit context: Context)(): TestStructA {
     let a: TestStructA =
     TestStructA{UnsafeCast<FixedArray>(kEmptyFixedArray), 13, 5};
     let b: TestStructA = a;
@@ -304,7 +304,7 @@ namespace test {
     y: TestStructA;
   }
 
-  macro TestStruct4(): TestStructC {
+  macro TestStruct4(implicit context: Context)(): TestStructC {
     return TestStructC{TestStruct2(), TestStruct2()};
   }
 
@@ -419,7 +419,9 @@ namespace test {
     }
   }
 
-  macro TypeswitchExample(x: Number | FixedArray): int32 {
+  type NumberOrFixedArray = Number | FixedArray;
+  macro TypeswitchExample(implicit context: Context)(x: NumberOrFixedArray):
+      int32 {
     let result: int32 = 0;
     typeswitch (IncrementIfSmi(x)) {
       case (x: FixedArray): {
@@ -447,7 +449,7 @@ namespace test {
     return result;
   }
 
-  macro TestTypeswitch() {
+  macro TestTypeswitch(implicit context: Context)() {
     check(TypeswitchExample(FromConstexpr<Smi>(5)) == 26);
     const a: FixedArray = AllocateZeroedFixedArray(3);
     check(TypeswitchExample(a) == 13);
@@ -461,7 +463,7 @@ namespace test {
     return o + 1;
   }
 
-  macro TestGenericOverload() {
+  macro TestGenericOverload(implicit context: Context)() {
     const xSmi: Smi = 5;
     const xObject: Object = xSmi;
     check(ExampleGenericOverload<Smi>(xSmi) == 6);
@@ -599,12 +601,12 @@ namespace test {
     }
   }
 
-  macro TestQualifiedAccess() {
+  macro TestQualifiedAccess(implicit context: Context)() {
     let s: Smi = 0;
     check(!array::IsJSArray(s));
   }
 
-  macro TestCatch1(context: Context): Smi {
+  macro TestCatch1(implicit context: Context)(): Smi {
     let r: Smi = 0;
     try {
       ThrowTypeError(context, kInvalidArrayLength);
@@ -614,29 +616,29 @@ namespace test {
     }
   }
 
-  macro TestCatch2Wrapper(context: Context): never {
+  macro TestCatch2Wrapper(implicit context: Context)(): never {
     ThrowTypeError(context, kInvalidArrayLength);
   }
 
-  macro TestCatch2(context: Context): Smi {
+  macro TestCatch2(implicit context: Context)(): Smi {
     let r: Smi = 0;
     try {
-      TestCatch2Wrapper(context);
+      TestCatch2Wrapper();
     } catch (e) {
       r = 2;
       return r;
     }
   }
 
-  macro TestCatch3WrapperWithLabel(context: Context): never
+  macro TestCatch3WrapperWithLabel(implicit context: Context)(): never
       labels Abort {
     ThrowTypeError(context, kInvalidArrayLength);
   }
 
-  macro TestCatch3(context: Context): Smi {
+  macro TestCatch3(implicit context: Context)(): Smi {
     let r: Smi = 0;
     try {
-      TestCatch3WrapperWithLabel(context) otherwise Abort;
+      TestCatch3WrapperWithLabel() otherwise Abort;
     }
     label Abort {
       return -1;

third_party/v8/builtins/array-sort.tq

@@ -257,25 +257,19 @@ namespace array {
     return kSuccess;
   }
 
-  extern macro UnsafeCastObjectToCompareBuiltinFn(Object): CompareBuiltinFn;
-  UnsafeCast<CompareBuiltinFn>(o: Object): CompareBuiltinFn {
-    return UnsafeCastObjectToCompareBuiltinFn(o);
+  UnsafeCast<CompareBuiltinFn>(implicit context: Context)(o: Object):
+      CompareBuiltinFn {
+    return %RawCast<CompareBuiltinFn>(o);
   }
-
-  extern macro UnsafeCastObjectToLoadFn(Object): LoadFn;
-  UnsafeCast<LoadFn>(o: Object): LoadFn {
-    return UnsafeCastObjectToLoadFn(o);
+  UnsafeCast<LoadFn>(implicit context: Context)(o: Object): LoadFn {
+    return %RawCast<LoadFn>(o);
   }
-
-  extern macro UnsafeCastObjectToStoreFn(Object): StoreFn;
-  UnsafeCast<StoreFn>(o: Object): StoreFn {
-    return UnsafeCastObjectToStoreFn(o);
+  UnsafeCast<StoreFn>(implicit context: Context)(o: Object): StoreFn {
+    return %RawCast<StoreFn>(o);
   }
-
-  extern macro UnsafeCastObjectToCanUseSameAccessorFn(Object):
-      CanUseSameAccessorFn;
-  UnsafeCast<CanUseSameAccessorFn>(o: Object): CanUseSameAccessorFn {
-    return UnsafeCastObjectToCanUseSameAccessorFn(o);
+  UnsafeCast<CanUseSameAccessorFn>(implicit context: Context)(o: Object):
+      CanUseSameAccessorFn {
+    return %RawCast<CanUseSameAccessorFn>(o);
   }
 
   builtin SortCompareDefault(
@@ -375,7 +369,8 @@ namespace array {
   // might have occurred. This means we cannot leave any pointer to the elements
   // backing store on the stack (since it would point to the filler object).
   // TODO(v8:7995): Remove reloading once left-trimming is removed.
-  macro ReloadElements(sortState: FixedArray): HeapObject {
+  macro ReloadElements(implicit context: Context)(sortState: FixedArray):
+      HeapObject {
     const receiver: JSReceiver = GetReceiver(sortState);
     if (sortState[kAccessorIdx] == kGenericElementsAccessorId) return receiver;
 
@@ -383,35 +378,40 @@ namespace array {
     return object.elements;
   }
 
-  macro GetInitialReceiverLength(sortState: FixedArray): Number {
+  macro GetInitialReceiverLength(implicit context:
+                                     Context)(sortState: FixedArray): Number {
     return UnsafeCast<Number>(sortState[kInitialReceiverLengthIdx]);
   }
 
-  macro GetLoadFn(sortState: FixedArray): LoadFn {
+  macro GetLoadFn(implicit context: Context)(sortState: FixedArray): LoadFn {
     return UnsafeCast<LoadFn>(sortState[kLoadFnIdx]);
   }
 
-  macro GetStoreFn(sortState: FixedArray): StoreFn {
+  macro GetStoreFn(implicit context: Context)(sortState: FixedArray): StoreFn {
     return UnsafeCast<StoreFn>(sortState[kStoreFnIdx]);
   }
 
-  macro GetCanUseSameAccessorFn(sortState: FixedArray): CanUseSameAccessorFn {
+  macro GetCanUseSameAccessorFn(implicit context: Context)(
+      sortState: FixedArray): CanUseSameAccessorFn {
     return UnsafeCast<CanUseSameAccessorFn>(
         sortState[kCanUseSameAccessorFnIdx]);
   }
 
-  macro GetReceiver(sortState: FixedArray): JSReceiver {
+  macro GetReceiver(implicit context: Context)(sortState: FixedArray):
+      JSReceiver {
     return UnsafeCast<JSReceiver>(sortState[kReceiverIdx]);
   }
 
   // Returns the temporary array without changing its size.
-  macro GetTempArray(sortState: FixedArray): FixedArray {
+  macro GetTempArray(implicit context: Context)(sortState: FixedArray):
+      FixedArray {
     return UnsafeCast<FixedArray>(sortState[kTempArrayIdx]);
   }
 
   // Re-loading the stack-size is done in a few places. The small macro allows
   // for easier invariant checks at all use sites.
-  macro GetPendingRunsSize(sortState: FixedArray): Smi {
+  macro GetPendingRunsSize(implicit context: Context)(sortState: FixedArray):
+      Smi {
     assert(TaggedIsSmi(sortState[kPendingRunsSizeIdx]));
     const stackSize: Smi = UnsafeCast<Smi>(sortState[kPendingRunsSizeIdx]);
 
@@ -423,7 +423,8 @@ namespace array {
     sortState[kPendingRunsSizeIdx] = value;
   }
 
-  macro GetPendingRunBase(pendingRuns: FixedArray, run: Smi): Smi {
+  macro GetPendingRunBase(implicit context:
+                              Context)(pendingRuns: FixedArray, run: Smi): Smi {
     return UnsafeCast<Smi>(pendingRuns[run << 1]);
   }
 
@@ -431,7 +432,8 @@ namespace array {
     pendingRuns[run << 1] = value;
   }
 
-  macro GetPendingRunLength(pendingRuns: FixedArray, run: Smi): Smi {
+  macro GetPendingRunLength(implicit context: Context)(
+      pendingRuns: FixedArray, run: Smi): Smi {
     return UnsafeCast<Smi>(pendingRuns[(run << 1) + 1]);
   }
 
@@ -439,7 +441,8 @@ namespace array {
     pendingRuns[(run << 1) + 1] = value;
   }
 
-  macro PushRun(sortState: FixedArray, base: Smi, length: Smi) {
+  macro PushRun(implicit context:
+                    Context)(sortState: FixedArray, base: Smi, length: Smi) {
     assert(GetPendingRunsSize(sortState) < kMaxMergePending);
 
     const stackSize: Smi = GetPendingRunsSize(sortState);
@@ -454,7 +457,8 @@ namespace array {
 
   // Returns the temporary array and makes sure that it is big enough.
   // TODO(szuend): Implement a better re-size strategy.
-  macro GetTempArray(sortState: FixedArray, requestedSize: Smi): FixedArray {
+  macro GetTempArray(implicit context: Context)(
+      sortState: FixedArray, requestedSize: Smi): FixedArray {
     const minSize: Smi = SmiMax(kSortStateTempSize, requestedSize);
 
     const currentSize: Smi = UnsafeCast<Smi>(sortState[kTempArraySizeIdx]);
@@ -471,7 +475,8 @@ namespace array {
   }
 
   // This macro jumps to the Bailout label iff kBailoutStatus is kFailure.
-  macro EnsureSuccess(sortState: FixedArray) labels Bailout {
+  macro EnsureSuccess(implicit context:
+                          Context)(sortState: FixedArray) labels Bailout {
     const status: Smi = UnsafeCast<Smi>(sortState[kBailoutStatusIdx]);
     if (status == kFailure) goto Bailout;
   }
@@ -882,8 +887,8 @@ namespace array {
     }
   }
 
-  macro LoadElementsOrTempArray(useTempArray: Boolean, sortState: FixedArray):
-      HeapObject {
+  macro LoadElementsOrTempArray(implicit context: Context)(
+      useTempArray: Boolean, sortState: FixedArray): HeapObject {
     return useTempArray == True ? GetTempArray(sortState) :
                                   ReloadElements(sortState);
   }
@@ -1535,7 +1540,8 @@ namespace array {
   }
 
   // Returns true iff run_length(n - 2) > run_length(n - 1) + run_length(n).
-  macro RunInvariantEstablished(pendingRuns: FixedArray, n: Smi): bool {
+  macro RunInvariantEstablished(implicit context: Context)(
+      pendingRuns: FixedArray, n: Smi): bool {
     if (n < 2) return true;
 
     const runLengthN: Smi = GetPendingRunLength(pendingRuns, n);