[torque] Improve formatting in format-torque

Issues/problems addressed: - Fix line-wrapping and indenting for long declarations including strings, e.g. generates and constexpr clauses. - Implement proper formatting for typeswitch statements - Fix formatting of operator declarations - Fix formatting of constexpr if-clauses (the constexpr is now included on the same line as the if and it doesn't mess up the formatting that - Fix formatting of label declarations on callables, the "label" keyword now always starts a new line with indentation. - Remove space after identifier name in generic parameter declarations, e.g. "<a : T>" is now "<a: T>" which is consistent with type specification formatting elsewhere. - Indent "otherwise" clauses that have been pushed to the next line. Also ran the formatter over all existing .tq files. Bug: v8:7793 Change-Id: I5adbb2ffa3d573deed062f9a5c1da57348c8fc71 Reviewed-on: https://chromium-review.googlesource.com/1238580 Commit-Queue: Daniel Clifford <danno@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Cr-Commit-Position: refs/heads/master@{#56158}

[torque] Improve formatting in format-torque
Issues/problems addressed: - Fix line-wrapping and indenting for long declarations including strings, e.g. generates and constexpr clauses. - Implement proper formatting for typeswitch statements - Fix formatting of operator declarations - Fix formatting of constexpr if-clauses (the constexpr is now included on the same line as the if and it doesn't mess up the formatting that - Fix formatting of label declarations on callables, the "label" keyword now always starts a new line with indentation. - Remove space after identifier name in generic parameter declarations, e.g. "<a : T>" is now "<a: T>" which is consistent with type specification formatting elsewhere. - Indent "otherwise" clauses that have been pushed to the next line. Also ran the formatter over all existing .tq files. Bug: v8:7793 Change-Id: I5adbb2ffa3d573deed062f9a5c1da57348c8fc71 Reviewed-on: https://chromium-review.googlesource.com/1238580 Commit-Queue: Daniel Clifford <danno@chromium.org> Reviewed-by: Tobias Tebbi <tebbi@chromium.org> Cr-Commit-Position: refs/heads/master@{#56158}
f088840a · Daniel Clifford · Commit Bot · c0f871a1 · f088840a · f088840a
Commit f088840a authored Sep 24, 2018 by Daniel Clifford Committed by Commit Bot Sep 24, 2018
12 changed files
--- a/src/builtins/array-foreach.tq
+++ b/src/builtins/array-foreach.tq
@@ -72,10 +72,10 @@ module array {
    }
  }
-  macro VisitAllElements<FixedArrayType : type>(
+  macro VisitAllElements<FixedArrayType: type>(
      context: Context, a: JSArray, len: Smi, callbackfn: Callable,
-      thisArg: Object): void labels
+      thisArg: Object): void
-  Bailout(Smi) {
+      labels Bailout(Smi) {
    let k: Smi = 0;
    const map: Map = a.map;
@@ -108,8 +108,8 @@ module array {
  macro FastArrayForEach(
      context: Context, o: JSReceiver, len: Number, callbackfn: Callable,
-      thisArg: Object): Object labels
+      thisArg: Object): Object
-  Bailout(Smi) {
+      labels Bailout(Smi) {
    let k: Smi = 0;
    try {
      const smiLen: Smi = Cast<Smi>(len) otherwise Slow;

--- a/src/builtins/array-lastindexof.tq
+++ b/src/builtins/array-lastindexof.tq
@@ -3,7 +3,7 @@
 // found in the LICENSE file.
 module array {
-  macro LoadWithHoleCheck<Elements : type>(
+  macro LoadWithHoleCheck<Elements: type>(
      elements: FixedArrayBase, index: Smi): Object
      labels IfHole;
@@ -15,8 +15,8 @@ module array {
    return element;
  }
-  LoadWithHoleCheck<FixedDoubleArray>(
+  LoadWithHoleCheck<FixedDoubleArray>(elements: FixedArrayBase, index: Smi):
-      elements: FixedArrayBase, index: Smi): Object
+      Object
      labels IfHole {
    const elements: FixedDoubleArray = UnsafeCast<FixedDoubleArray>(elements);
    const element: float64 = LoadDoubleWithHoleCheck(elements, index)
@@ -24,7 +24,7 @@ module array {
    return AllocateHeapNumberWithValue(element);
  }
-  macro FastArrayLastIndexOf<Elements : type>(
+  macro FastArrayLastIndexOf<Elements: type>(
      context: Context, array: JSArray, length: Smi, from: Smi,
      searchElement: Object): Smi {
    const elements: FixedArrayBase = array.elements;

--- a/src/builtins/array-reverse.tq
+++ b/src/builtins/array-reverse.tq
@@ -3,7 +3,7 @@
 // found in the LICENSE file.
 module array {
-  macro LoadElement<ElementsAccessor : type, T : type>(
+  macro LoadElement<ElementsAccessor: type, T: type>(
      elements: FixedArrayBase, index: Smi): T;
  LoadElement<FastPackedSmiElements, Smi>(
@@ -31,7 +31,7 @@ module array {
    }
  }
-  macro StoreElement<ElementsAccessor : type, T : type>(
+  macro StoreElement<ElementsAccessor: type, T: type>(
      elements: FixedArrayBase, index: Smi, value: T);
  StoreElement<FastPackedSmiElements, Smi>(
@@ -57,7 +57,7 @@ module array {
  // Fast-path for all PACKED_* elements kinds. These do not need to check
  // whether a property is present, so we can simply swap them using fast
  // FixedArray loads/stores.
-  macro FastPackedArrayReverse<Accessor : type, T : type>(
+  macro FastPackedArrayReverse<Accessor: type, T: type>(
      elements: FixedArrayBase, length: Smi) {
    let lower: Smi = 0;
    let upper: Smi = length - 1;

--- a/src/builtins/array-splice.tq
+++ b/src/builtins/array-splice.tq
@@ -7,7 +7,7 @@ module array {
  // FixedArrayType. Most of this behavior is outsourced to ExtractFixedArray(),
  // but the special case of wanting to have a FixedDoubleArray when given a
  // zero-length input FixedArray is handled here.
-  macro Extract<FixedArrayType : type>(
+  macro Extract<FixedArrayType: type>(
      elements: FixedArrayBase, first: Smi, count: Smi,
      capacity: Smi): FixedArrayType {
    return UnsafeCast<FixedArrayType>(
@@ -24,10 +24,11 @@ module array {
        ExtractFixedArray(elements, first, count, capacity));
  }
-  macro FastSplice<FixedArrayType : type, ElementType : type>(
+  macro FastSplice<FixedArrayType: type, ElementType: type>(
      args: constexpr Arguments, a: JSArray, length: Smi, newLength: Smi,
      lengthDelta: Smi, actualStart: Smi, insertCount: Smi,
-      actualDeleteCount: Smi): void labels Bailout {
+      actualDeleteCount: Smi): void
+      labels Bailout {
    const elements: FixedArrayBase = a.elements;
    const elementsMap: Map = elements.map;

--- a/src/builtins/array-unshift.tq
+++ b/src/builtins/array-unshift.tq
@@ -6,7 +6,8 @@ module array {
  extern builtin ArrayUnshift(Context, JSFunction, Object, int32);
  macro TryFastArrayUnshift(
-      context: Context, receiver: Object, arguments: constexpr Arguments): never
+      context: Context, receiver: Object, arguments: constexpr Arguments):
+      never
      labels Slow {
    EnsureFastJSArray(context, receiver) otherwise Slow;
    const array: JSArray = UnsafeCast<JSArray>(receiver);

--- a/src/builtins/array.tq
+++ b/src/builtins/array.tq
@@ -35,8 +35,8 @@ module array {
    assert(IsFastSmiOrTaggedElementsKind(array.map.elements_kind));
    const length: Smi = array.length_fast;
-    array.elements = ExtractFixedArray(
+    array.elements =
-        elements, 0, length, length, kFixedArrays);
+        ExtractFixedArray(elements, 0, length, length, kFixedArrays);
    assert(array.elements.map != kCOWMap);
  }

--- a/src/builtins/base.tq
+++ b/src/builtins/base.tq
@@ -42,27 +42,31 @@ type Callable = JSFunction|JSBoundFunction|JSProxy;
 type Map extends HeapObject generates 'TNode<Map>';
 type FixedArrayBase extends HeapObject generates 'TNode<FixedArrayBase>';
 type FixedArray extends FixedArrayBase generates 'TNode<FixedArray>';
-type FixedDoubleArray extends FixedArrayBase generates
+type FixedDoubleArray extends FixedArrayBase
-'TNode<FixedDoubleArray>';
+    generates 'TNode<FixedDoubleArray>';
-type FixedTypedArrayBase extends FixedArrayBase generates
+type FixedTypedArrayBase extends FixedArrayBase
-'TNode<FixedTypedArrayBase>';
+    generates 'TNode<FixedTypedArrayBase>';
-type FixedTypedArray extends FixedTypedArrayBase generates
+type FixedTypedArray extends FixedTypedArrayBase
-'TNode<FixedTypedArray>';
+    generates 'TNode<FixedTypedArray>';
-type NumberDictionary extends HeapObject generates 'TNode<NumberDictionary>';
+type NumberDictionary extends HeapObject
+    generates 'TNode<NumberDictionary>';
 type JSArrayBuffer extends JSObject generates 'TNode<JSArrayBuffer>';
-type JSArrayBufferView extends JSObject generates 'TNode<JSArrayBufferView>';
+type JSArrayBufferView extends JSObject
-type JSTypedArray extends JSArrayBufferView generates 'TNode<JSTypedArray>';
+    generates 'TNode<JSArrayBufferView>';
+type JSTypedArray extends JSArrayBufferView
+    generates 'TNode<JSTypedArray>';
 type JSDataView extends JSArrayBufferView generates 'TNode<JSDataView>';
 type InstanceType generates 'TNode<Int32T>' constexpr 'InstanceType';
 type ElementsKind generates 'TNode<Int32T>' constexpr 'ElementsKind';
 type LanguageMode generates 'TNode<Smi>' constexpr 'LanguageMode';
-type ExtractFixedArrayFlags generates
+type ExtractFixedArrayFlags
-'TNode<Smi>' constexpr 'ExtractFixedArrayFlags';
+    generates 'TNode<Smi>' constexpr 'ExtractFixedArrayFlags';
 type ParameterMode generates 'TNode<Int32T>' constexpr 'ParameterMode';
 type RootIndex generates 'TNode<Int32T>' constexpr 'RootIndex';
-type WriteBarrierMode generates 'TNode<Int32T>' constexpr 'WriteBarrierMode';
+type WriteBarrierMode
+    generates 'TNode<Int32T>' constexpr 'WriteBarrierMode';
 type MessageTemplate constexpr 'MessageTemplate::Template';
@@ -70,17 +74,18 @@ type ToIntegerTruncationMode constexpr 'ToIntegerTruncationMode';
 const NO_ELEMENTS: constexpr ElementsKind generates 'NO_ELEMENTS';
-const PACKED_SMI_ELEMENTS: constexpr ElementsKind generates
+const PACKED_SMI_ELEMENTS:
-'PACKED_SMI_ELEMENTS';
+    constexpr ElementsKind generates 'PACKED_SMI_ELEMENTS';
-const HOLEY_SMI_ELEMENTS: constexpr ElementsKind generates 'HOLEY_SMI_ELEMENTS';
+const HOLEY_SMI_ELEMENTS:
+    constexpr ElementsKind generates 'HOLEY_SMI_ELEMENTS';
 const PACKED_ELEMENTS: constexpr ElementsKind generates 'PACKED_ELEMENTS';
 const HOLEY_ELEMENTS: constexpr ElementsKind generates 'HOLEY_ELEMENTS';
-const PACKED_DOUBLE_ELEMENTS: constexpr ElementsKind generates
+const PACKED_DOUBLE_ELEMENTS:
-'PACKED_DOUBLE_ELEMENTS';
+    constexpr ElementsKind generates 'PACKED_DOUBLE_ELEMENTS';
-const HOLEY_DOUBLE_ELEMENTS: constexpr ElementsKind generates
+const HOLEY_DOUBLE_ELEMENTS:
-'HOLEY_DOUBLE_ELEMENTS';
+    constexpr ElementsKind generates 'HOLEY_DOUBLE_ELEMENTS';
-const DICTIONARY_ELEMENTS: constexpr ElementsKind generates
+const DICTIONARY_ELEMENTS:
-'DICTIONARY_ELEMENTS';
+    constexpr ElementsKind generates 'DICTIONARY_ELEMENTS';
 const UINT8_ELEMENTS: constexpr ElementsKind generates 'UINT8_ELEMENTS';
 const INT8_ELEMENTS: constexpr ElementsKind generates 'INT8_ELEMENTS';
@@ -90,10 +95,12 @@ const UINT32_ELEMENTS: constexpr ElementsKind generates 'UINT32_ELEMENTS';
 const INT32_ELEMENTS: constexpr ElementsKind generates 'INT32_ELEMENTS';
 const FLOAT32_ELEMENTS: constexpr ElementsKind generates 'FLOAT32_ELEMENTS';
 const FLOAT64_ELEMENTS: constexpr ElementsKind generates 'FLOAT64_ELEMENTS';
-const UINT8_CLAMPED_ELEMENTS: constexpr ElementsKind generates
+const UINT8_CLAMPED_ELEMENTS:
-'UINT8_CLAMPED_ELEMENTS';
+    constexpr ElementsKind generates 'UINT8_CLAMPED_ELEMENTS';
-const BIGUINT64_ELEMENTS: constexpr ElementsKind generates 'BIGUINT64_ELEMENTS';
+const BIGUINT64_ELEMENTS:
-const BIGINT64_ELEMENTS: constexpr ElementsKind generates 'BIGINT64_ELEMENTS';
+    constexpr ElementsKind generates 'BIGUINT64_ELEMENTS';
+const BIGINT64_ELEMENTS:
+    constexpr ElementsKind generates 'BIGINT64_ELEMENTS';
 type FixedUint8Array extends FixedTypedArray;
 type FixedInt8Array extends FixedTypedArray;
@@ -107,42 +114,42 @@ type FixedUint8ClampedArray extends FixedTypedArray;
 type FixedBigUint64Array extends FixedTypedArray;
 type FixedBigInt64Array extends FixedTypedArray;
-const kFixedDoubleArrays: constexpr ExtractFixedArrayFlags generates
+const kFixedDoubleArrays: constexpr ExtractFixedArrayFlags
-'ExtractFixedArrayFlag::kFixedDoubleArrays';
+    generates 'ExtractFixedArrayFlag::kFixedDoubleArrays';
-const kAllFixedArrays: constexpr ExtractFixedArrayFlags generates
+const kAllFixedArrays: constexpr ExtractFixedArrayFlags
-'ExtractFixedArrayFlag::kAllFixedArrays';
+    generates 'ExtractFixedArrayFlag::kAllFixedArrays';
-const kFixedArrays: constexpr ExtractFixedArrayFlags generates
+const kFixedArrays: constexpr ExtractFixedArrayFlags
-'ExtractFixedArrayFlag::kFixedArrays';
+    generates 'ExtractFixedArrayFlag::kFixedArrays';
-const kFixedCOWArrayMapRootIndex: constexpr RootIndex generates
+const kFixedCOWArrayMapRootIndex:
-'RootIndex::kFixedCOWArrayMap';
+    constexpr RootIndex generates 'RootIndex::kFixedCOWArrayMap';
-const kEmptyFixedArrayRootIndex: constexpr RootIndex generates
+const kEmptyFixedArrayRootIndex:
-'RootIndex::kEmptyFixedArray';
+    constexpr RootIndex generates 'RootIndex::kEmptyFixedArray';
-const kInvalidArrayLength: constexpr MessageTemplate generates
+const kInvalidArrayLength: constexpr MessageTemplate
-'MessageTemplate::kInvalidArrayLength';
+    generates 'MessageTemplate::kInvalidArrayLength';
-const kCalledNonCallable: constexpr MessageTemplate generates
+const kCalledNonCallable: constexpr MessageTemplate
-'MessageTemplate::kCalledNonCallable';
+    generates 'MessageTemplate::kCalledNonCallable';
-const kCalledOnNullOrUndefined: constexpr MessageTemplate generates
+const kCalledOnNullOrUndefined: constexpr MessageTemplate
-'MessageTemplate::kCalledOnNullOrUndefined';
+    generates 'MessageTemplate::kCalledOnNullOrUndefined';
 const kMaxSafeInteger: constexpr float64 generates 'kMaxSafeInteger';
-const kTruncateMinusZero: constexpr ToIntegerTruncationMode generates
+const kTruncateMinusZero: constexpr ToIntegerTruncationMode
-'ToIntegerTruncationMode::kTruncateMinusZero';
+    generates 'ToIntegerTruncationMode::kTruncateMinusZero';
-const kNotTypedArray: constexpr MessageTemplate generates
+const kNotTypedArray:
-'MessageTemplate::kNotTypedArray';
+    constexpr MessageTemplate generates 'MessageTemplate::kNotTypedArray';
-const kDetachedOperation: constexpr MessageTemplate generates
+const kDetachedOperation: constexpr MessageTemplate
-'MessageTemplate::kDetachedOperation';
+    generates 'MessageTemplate::kDetachedOperation';
-const kBadSortComparisonFunction: constexpr MessageTemplate generates
+const kBadSortComparisonFunction: constexpr MessageTemplate
-'MessageTemplate::kBadSortComparisonFunction';
+    generates 'MessageTemplate::kBadSortComparisonFunction';
-const kIncompatibleMethodReceiver: constexpr MessageTemplate generates
+const kIncompatibleMethodReceiver: constexpr MessageTemplate
-'MessageTemplate::kIncompatibleMethodReceiver';
+    generates 'MessageTemplate::kIncompatibleMethodReceiver';
-const kInvalidDataViewAccessorOffset: constexpr MessageTemplate generates
+const kInvalidDataViewAccessorOffset: constexpr MessageTemplate
-'MessageTemplate::kInvalidDataViewAccessorOffset';
+    generates 'MessageTemplate::kInvalidDataViewAccessorOffset';
-const kStrictReadOnlyProperty: constexpr MessageTemplate generates
+const kStrictReadOnlyProperty: constexpr MessageTemplate
-'MessageTemplate::kStrictReadOnlyProperty';
+    generates 'MessageTemplate::kStrictReadOnlyProperty';
 extern macro TheHoleConstant(): Oddball;
 extern macro NullConstant(): Oddball;
@@ -167,10 +174,11 @@ const kStrict: constexpr LanguageMode generates 'LanguageMode::kStrict';
 const kSloppy: constexpr LanguageMode generates 'LanguageMode::kSloppy';
 const SMI_PARAMETERS: constexpr ParameterMode generates 'SMI_PARAMETERS';
-const INTPTR_PARAMETERS: constexpr ParameterMode generates 'INTPTR_PARAMETERS';
+const INTPTR_PARAMETERS:
+    constexpr ParameterMode generates 'INTPTR_PARAMETERS';
-const SKIP_WRITE_BARRIER: constexpr WriteBarrierMode
+const SKIP_WRITE_BARRIER:
-generates 'SKIP_WRITE_BARRIER';
+    constexpr WriteBarrierMode generates 'SKIP_WRITE_BARRIER';
 extern macro Is64(): constexpr bool;
@@ -200,7 +208,8 @@ extern macro ThrowTypeError(
    Context, constexpr MessageTemplate, Object, Object, Object): never;
 extern macro ArraySpeciesCreate(Context, Object, Number): JSReceiver;
 extern macro InternalArrayCreate(Context, Number): JSArray;
-extern macro EnsureArrayPushable(Map): ElementsKind labels Bailout;
+extern macro EnsureArrayPushable(Map): ElementsKind
+    labels Bailout;
 extern macro EnsureArrayLengthWritable(Map) labels Bailout;
 extern builtin ToObject(Context, Object): JSReceiver;
@@ -263,20 +272,18 @@ extern operator '==' macro Float64Equal(float64, float64): bool;
 extern operator '!=' macro Float64NotEqual(float64, float64): bool;
 extern operator '>' macro Float64GreaterThan(float64, float64): bool;
-extern operator
+extern operator '==' macro BranchIfNumberEqual(Number, Number): never
-'==' macro BranchIfNumberEqual(Number, Number): never labels Taken, NotTaken;
+    labels Taken, NotTaken;
-extern operator
+extern operator '<' macro BranchIfNumberLessThan(Number, Number): never
-'<' macro BranchIfNumberLessThan(Number, Number): never labels Taken, NotTaken;
+    labels Taken, NotTaken;
-extern operator
+extern operator '<=' macro BranchIfNumberLessThanOrEqual(Number, Number): never
-'<=' macro BranchIfNumberLessThanOrEqual(Number, Number): never labels Taken,
+    labels Taken, NotTaken;
-    NotTaken;
+extern operator '>' macro BranchIfNumberGreaterThan(Number, Number): never
-extern operator
+    labels Taken, NotTaken;
-'>' macro BranchIfNumberGreaterThan(Number, Number): never labels Taken,
-    NotTaken;
 extern operator '>=' macro BranchIfNumberGreaterThanOrEqual(Number, Number):
-    never labels Taken,
+    never
-    NotTaken;
+    labels Taken, NotTaken;
 extern operator '==' macro WordEqual(Object, Object): bool;
 extern operator '!=' macro WordNotEqual(Object, Object): bool;
@@ -337,64 +344,81 @@ extern operator '!' macro IsFalse(Boolean): bool;
 extern operator '.map' macro LoadMap(HeapObject): Map;
 extern operator '.map=' macro StoreMap(HeapObject, Map);
-extern operator
+extern operator '.instanceType' macro LoadInstanceType(HeapObject):
-'.instanceType' macro LoadInstanceType(HeapObject): InstanceType;
+    InstanceType;
 extern operator '.length' macro LoadStringLengthAsWord(String): intptr;
 extern operator '.length' macro GetArgumentsLength(constexpr Arguments): intptr;
-extern operator
+extern operator '[]' macro GetArgumentValue(
-'[]' macro GetArgumentValue(constexpr Arguments, intptr): Object;
+    constexpr Arguments, intptr): Object;
 extern macro TaggedIsSmi(Object): bool;
 extern macro TaggedIsNotSmi(Object): bool;
 extern macro TaggedIsPositiveSmi(Object): bool;
-extern macro HeapObjectToJSDataView(HeapObject): JSDataView labels CastError;
+extern macro HeapObjectToJSDataView(HeapObject): JSDataView
-extern macro TaggedToHeapObject(Object): HeapObject labels CastError;
+    labels CastError;
-extern macro TaggedToSmi(Object): Smi labels CastError;
+extern macro TaggedToHeapObject(Object): HeapObject
-extern macro HeapObjectToJSArray(HeapObject): JSArray labels CastError;
+    labels CastError;
-extern macro HeapObjectToCallable(HeapObject): Callable labels CastError;
+extern macro TaggedToSmi(Object): Smi
-extern macro HeapObjectToFixedArray(HeapObject): FixedArray labels CastError;
+    labels CastError;
-extern macro HeapObjectToFixedDoubleArray(HeapObject):
+extern macro HeapObjectToJSArray(HeapObject): JSArray
-    FixedDoubleArray labels CastError;
+    labels CastError;
-extern macro TaggedToNumber(Object): Number labels CastError;
+extern macro HeapObjectToCallable(HeapObject): Callable
+    labels CastError;
-macro CastHeapObject<A : type>(o: HeapObject): A labels CastError;
+extern macro HeapObjectToFixedArray(HeapObject): FixedArray
-CastHeapObject<HeapObject>(o: HeapObject): HeapObject labels CastError {
+    labels CastError;
+extern macro HeapObjectToFixedDoubleArray(HeapObject): FixedDoubleArray
+    labels CastError;
+extern macro TaggedToNumber(Object): Number
+    labels CastError;
+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 {
+CastHeapObject<FixedArray>(o: HeapObject): FixedArray
+    labels CastError {
  return HeapObjectToFixedArray(o) otherwise CastError;
 }
-CastHeapObject<FixedDoubleArray>(o: HeapObject):
+CastHeapObject<FixedDoubleArray>(o: HeapObject): FixedDoubleArray
-    FixedDoubleArray labels CastError {
+    labels CastError {
  return HeapObjectToFixedDoubleArray(o) otherwise CastError;
 }
-CastHeapObject<JSDataView>(o: HeapObject): JSDataView labels CastError {
+CastHeapObject<JSDataView>(o: HeapObject): JSDataView
+    labels CastError {
  return HeapObjectToJSDataView(o) otherwise CastError;
 }
-CastHeapObject<Callable>(o: HeapObject): Callable labels CastError {
+CastHeapObject<Callable>(o: HeapObject): Callable
+    labels CastError {
  return HeapObjectToCallable(o) otherwise CastError;
 }
-CastHeapObject<JSArray>(o: HeapObject): JSArray labels CastError {
+CastHeapObject<JSArray>(o: HeapObject): JSArray
+    labels CastError {
  return HeapObjectToJSArray(o) otherwise CastError;
 }
-macro Cast<A : type>(o: HeapObject): A labels CastError {
+macro Cast<A: type>(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 labels CastError {
+macro Cast<A: type>(o: Object): A
+    labels CastError {
  return CastHeapObject<A>(TaggedToHeapObject(o) otherwise CastError)
      otherwise CastError;
 }
-Cast<Smi>(o: Object): Smi labels CastError {
+Cast<Smi>(o: Object): Smi
+    labels CastError {
  return TaggedToSmi(o) otherwise CastError;
 }
-Cast<Number>(o: Object): Number labels CastError {
+Cast<Number>(o: Object): Number
+    labels CastError {
  return TaggedToNumber(o) otherwise CastError;
 }
@@ -435,7 +459,7 @@ extern macro StringConstant(constexpr string): String;
 extern macro LanguageModeConstant(constexpr LanguageMode): LanguageMode;
 extern macro Int32Constant(constexpr ElementsKind): ElementsKind;
-macro FromConstexpr<A : type>(o: constexpr int31): A;
+macro FromConstexpr<A: type>(o: constexpr int31): A;
 FromConstexpr<intptr>(i: constexpr int31): intptr {
  return IntPtrConstant(i);
 }
@@ -460,7 +484,7 @@ FromConstexpr<Number>(i: constexpr int31): Number {
 FromConstexpr<float64>(i: constexpr int31): float64 {
  return Float64Constant(i);
 }
-macro FromConstexpr<A : type>(o: constexpr int32): A;
+macro FromConstexpr<A: type>(o: constexpr int32): A;
 FromConstexpr<intptr>(i: constexpr int32): intptr {
  return IntPtrConstant(i);
 }
@@ -470,23 +494,23 @@ FromConstexpr<int32>(i: constexpr int32): int32 {
 FromConstexpr<Number>(i: constexpr int32): Number {
  return NumberConstant(i);
 }
-macro FromConstexpr<A : type>(o: constexpr float64): A;
+macro FromConstexpr<A: type>(o: constexpr float64): A;
 FromConstexpr<Number>(f: constexpr float64): Number {
  return NumberConstant(f);
 }
-macro FromConstexpr<A : type>(b: constexpr bool): A;
+macro FromConstexpr<A: type>(b: constexpr bool): A;
 FromConstexpr<bool>(b: constexpr bool): bool {
  return BoolConstant(b);
 }
-macro FromConstexpr<A : type>(l: constexpr LanguageMode): A;
+macro FromConstexpr<A: type>(l: constexpr LanguageMode): A;
 FromConstexpr<LanguageMode>(b: constexpr LanguageMode): LanguageMode {
  return LanguageModeConstant(b);
 }
-macro FromConstexpr<A : type>(e: constexpr ElementsKind): A;
+macro FromConstexpr<A: type>(e: constexpr ElementsKind): A;
 FromConstexpr<ElementsKind>(e: constexpr ElementsKind): ElementsKind {
  return Int32Constant(e);
 }
-macro FromConstexpr<A : type>(s: constexpr string): A;
+macro FromConstexpr<A: type>(s: constexpr string): A;
 FromConstexpr<String>(s: constexpr string): String {
  return StringConstant(s);
 }
@@ -494,17 +518,17 @@ FromConstexpr<Object>(s: constexpr string): Object {
  return StringConstant(s);
 }
-macro Convert<A : type>(i: constexpr int31): A {
+macro Convert<A: type>(i: constexpr int31): A {
  return i;
 }
 extern macro ConvertElementsKindToInt(ElementsKind): int32;
-macro Convert<A : type>(elementsKind: ElementsKind): A;
+macro Convert<A: type>(elementsKind: ElementsKind): A;
 Convert<int32>(elementsKind: ElementsKind): int32 {
  return ConvertElementsKindToInt(elementsKind);
 }
-macro Convert<A : type>(i: int32): A;
+macro Convert<A: type>(i: int32): A;
 Convert<Number>(i: int32): Number {
  return ChangeInt32ToTagged(i);
 }
@@ -514,7 +538,7 @@ Convert<intptr>(i: int32): intptr {
 Convert<Smi>(i: int32): Smi {
  return SmiFromInt32(i);
 }
-macro Convert<A : type>(ui: uint32): A;
+macro Convert<A: type>(ui: uint32): A;
 Convert<Number>(ui: uint32): Number {
  return ChangeUint32ToTagged(ui);
 }
@@ -524,37 +548,37 @@ Convert<Smi>(ui: uint32): Smi {
 Convert<uintptr>(ui: uint32): uintptr {
  return ChangeUint32ToWord(ui);
 }
-macro Convert<A : type>(i: intptr): A;
+macro Convert<A: type>(i: intptr): A;
 Convert<int32>(i: intptr): int32 {
  return TruncateIntPtrToInt32(i);
 }
 Convert<Smi>(i: intptr): Smi {
  return SmiTag(i);
 }
-macro Convert<A : type>(ui: uintptr): A;
+macro Convert<A: type>(ui: uintptr): A;
 Convert<uint32>(ui: uintptr): uint32 {
  return Unsigned(TruncateIntPtrToInt32(Signed(ui)));
 }
-macro Convert<A : type>(s: Smi): A;
+macro Convert<A: type>(s: Smi): A;
 Convert<intptr>(s: Smi): intptr {
  return SmiUntag(s);
 }
 Convert<int32>(s: Smi): int32 {
  return SmiToInt32(s);
 }
-macro Convert<A : type>(h: HeapNumber): A;
+macro Convert<A: type>(h: HeapNumber): A;
 Convert<float64>(h: HeapNumber): float64 {
  return LoadHeapNumberValue(h);
 }
-macro Convert<A : type>(n: Number): A;
+macro Convert<A: type>(n: Number): A;
 Convert<float64>(n: Number): float64 {
  return ChangeNumberToFloat64(n);
 }
-macro Convert<A : type>(f: float32): A;
+macro Convert<A: type>(f: float32): A;
 Convert<float64>(f: float32): float64 {
  return ChangeFloat32ToFloat64(f);
 }
-macro Convert<A : type>(d: float64): A;
+macro Convert<A: type>(d: float64): A;
 Convert<Number>(d: float64): Number {
  return AllocateHeapNumberWithValue(d);
 }
@@ -567,7 +591,7 @@ Convert<Number>(ui: uintptr): Number {
 Convert<uintptr>(d: float64): uintptr {
  return ChangeFloat64ToUintPtr(d);
 }
-macro Convert<A : type>(r: RawPtr): A;
+macro Convert<A: type>(r: RawPtr): A;
 Convert<uintptr>(r: RawPtr): uintptr {
  return Unsigned(r);
 }
@@ -591,11 +615,11 @@ extern macro UnsafeCastObjectToJSReceiver(Object): JSReceiver;
 extern macro UnsafeCastObjectToJSObject(Object): JSObject;
 extern macro UnsafeCastObjectToMap(Object): Map;
-macro UnsafeCast<A : type>(n: Number): A;
+macro UnsafeCast<A: type>(n: Number): A;
 UnsafeCast<HeapNumber>(n: Number): HeapNumber {
  return UnsafeCastNumberToHeapNumber(n);
 }
-macro UnsafeCast<A : type>(o: Object): A;
+macro UnsafeCast<A: type>(o: Object): A;
 UnsafeCast<Object>(o: Object): Object {
  return o;
 }
@@ -646,9 +670,10 @@ const kCOWMap: Map = UnsafeCast<Map>(LoadRoot(kFixedCOWArrayMapRootIndex));
 const kEmptyFixedArray: FixedArrayBase =
    UnsafeCast<FixedArrayBase>(LoadRoot(kEmptyFixedArrayRootIndex));
-extern macro BranchIfFastJSArray(Object, Context): never labels Taken, NotTaken;
+extern macro BranchIfFastJSArray(Object, Context): never
-extern macro BranchIfNotFastJSArray(Object, Context): never labels Taken,
+    labels Taken, NotTaken;
-    NotTaken;
+extern macro BranchIfNotFastJSArray(Object, Context): never
+    labels Taken, NotTaken;
 macro EnsureFastJSArray(context: Context, object: Object) labels Bailout {
  if (BranchIfNotFastJSArray(object, context)) goto Bailout;
@@ -660,14 +685,14 @@ extern macro IsArraySpeciesProtectorCellInvalid(): bool;
 extern macro IsTypedArraySpeciesProtectorCellInvalid(): bool;
 extern macro IsPromiseSpeciesProtectorCellInvalid(): bool;
-extern operator
+extern operator '.buffer' macro LoadTypedArrayBuffer(JSTypedArray):
-'.buffer' macro LoadTypedArrayBuffer(JSTypedArray): JSArrayBuffer;
+    JSArrayBuffer;
 extern operator '.data_ptr' macro LoadDataPtr(JSTypedArray): RawPtr;
 extern operator '.elements_kind' macro LoadMapElementsKind(Map): ElementsKind;
-extern operator
+extern operator '.elements_kind' macro LoadElementsKind(JSTypedArray):
-'.elements_kind' macro LoadElementsKind(JSTypedArray): ElementsKind;
+    ElementsKind;
 extern operator '.elements' macro LoadElements(JSObject): FixedArrayBase;
 extern operator '.elements=' macro StoreElements(JSObject, FixedArrayBase);
@@ -680,14 +705,14 @@ extern operator '.length=' macro StoreJSArrayLength(JSArray, Smi);
 extern operator '.length' macro LoadFixedArrayBaseLength(FixedArrayBase): Smi;
 extern operator '[]' macro LoadFixedArrayElement(FixedArray, intptr): Object;
 extern operator '[]' macro LoadFixedArrayElement(FixedArray, Smi): Object;
-extern operator
+extern operator '[]' macro LoadFixedArrayElement(
-'[]' macro LoadFixedArrayElement(FixedArray, constexpr int31): Object;
+    FixedArray, constexpr int31): Object;
-extern operator
+extern operator '[]=' macro StoreFixedArrayElement(
-'[]=' macro StoreFixedArrayElement(FixedArray, intptr, Object): void;
+    FixedArray, intptr, Object): void;
-extern operator
+extern operator '[]=' macro StoreFixedArrayElement(
-'[]=' macro StoreFixedArrayElement(FixedArray, constexpr int31, Object): void;
+    FixedArray, constexpr int31, Object): void;
-extern operator
+extern operator '[]=' macro StoreFixedArrayElementSmi(
-'[]=' macro StoreFixedArrayElementSmi(FixedArray, Smi, Object): void;
+    FixedArray, Smi, Object): void;
 operator '[]=' macro StoreFixedDoubleArrayNumber(
    a: FixedDoubleArray, index: Smi, value: Number): void {
  a[index] = Convert<float64>(value);
@@ -708,9 +733,8 @@ macro StoreFixedDoubleArrayElementWithSmiIndex(
  StoreFixedDoubleArrayElement(array, index, value, SMI_PARAMETERS);
 }
-extern macro BasicLoadNumberDictionaryElement(NumberDictionary, intptr):
+extern macro BasicLoadNumberDictionaryElement(NumberDictionary, intptr): Object
-    Object labels NotData,
+    labels NotData, IfHole;
-    IfHole;
 extern macro BasicStoreNumberDictionaryElement(NumberDictionary, intptr, Object)
 labels NotData, IfHole, ReadOnly;
@@ -757,12 +781,11 @@ extern macro AllocateJSArray(constexpr ElementsKind, Map, Smi, Smi): JSArray;
 extern macro IsElementsKindGreaterThan(
    ElementsKind, constexpr ElementsKind): bool;
-extern operator
+extern operator '[]=' macro StoreFixedDoubleArrayElementSmi(
-'[]=' macro StoreFixedDoubleArrayElementSmi(
    FixedDoubleArray, Smi, float64): void;
 extern macro LoadDoubleWithHoleCheck(FixedDoubleArray, Smi): float64
-labels IfHole;
+    labels IfHole;
 extern macro StoreFixedDoubleArrayHoleSmi(FixedDoubleArray, Smi): void;
 extern macro Call(Context, Callable, Object): Object;
@@ -775,15 +798,17 @@ extern macro Call(
    Context, Callable, Object, Object, Object, Object, Object, Object): Object;
 extern macro ExtractFixedArray(FixedArrayBase, Smi, Smi, Smi): FixedArrayBase;
-extern macro ExtractFixedArray(FixedArrayBase, Smi, Smi, Smi,
+extern macro ExtractFixedArray(
+    FixedArrayBase, Smi, Smi, Smi,
    constexpr ExtractFixedArrayFlags): FixedArrayBase;
 extern builtin ExtractFastJSArray(Context, JSArray, Smi, Smi): JSArray;
-macro LoadElementNoHole<T : type>(a: JSArray, index: Smi): Object labels IfHole;
+macro LoadElementNoHole<T: type>(a: JSArray, index: Smi): Object
+    labels IfHole;
 LoadElementNoHole<FixedArray>(a: JSArray, index: Smi): Object
-labels IfHole {
+    labels IfHole {
  try {
    let elements: FixedArray =
        Cast<FixedArray>(a.elements) otherwise Unexpected;
@@ -799,7 +824,7 @@ labels IfHole {
 }
 LoadElementNoHole<FixedDoubleArray>(a: JSArray, index: Smi): Object
-labels IfHole {
+    labels IfHole {
  try {
    let elements: FixedDoubleArray =
        Cast<FixedDoubleArray>(a.elements) otherwise Unexpected;
@@ -811,8 +836,9 @@ labels IfHole {
  }
 }
-extern macro TransitionElementsKind(
+extern macro TransitionElementsKind(JSObject, Map, ElementsKind, ElementsKind):
-    JSObject, Map, ElementsKind, ElementsKind): void labels Bailout;
+    void
+    labels Bailout;
 extern macro IsCallable(HeapObject): bool;
 extern macro IsJSArray(HeapObject): bool;
@@ -830,17 +856,19 @@ extern macro LoadTargetFromFrame(): JSFunction;
 // Return true iff number is NaN.
 macro NumberIsNaN(number: Number): bool {
-  typeswitch(number) {
+  typeswitch (number) {
-    case (Smi) {
+    case (Smi): {
      return false;
-    } case (hn : HeapNumber) {
+    }
+    case (hn: HeapNumber): {
      let value: float64 = Convert<float64>(hn);
      return value != value;
    }
  }
 }
-extern macro BranchIfToBooleanIsTrue(Object): never labels Taken, NotTaken;
+extern macro BranchIfToBooleanIsTrue(Object): never
+    labels Taken, NotTaken;
 macro ToBoolean(obj: Object): bool {
  if (BranchIfToBooleanIsTrue(obj)) {
@@ -850,7 +878,8 @@ macro ToBoolean(obj: Object): bool {
  }
 }
-macro ToIndex(input: Object, context: Context): Number labels RangeError {
+macro ToIndex(input: Object, context: Context): Number
+    labels RangeError {
  if (input == Undefined) {
    return 0;
  }

--- a/src/builtins/data-view.tq
+++ b/src/builtins/data-view.tq
@@ -3,7 +3,6 @@
 // found in the LICENSE file.
 module data_view {
  extern operator '.buffer'
      macro LoadJSArrayBufferViewBuffer(JSArrayBufferView): JSArrayBuffer;
  extern operator '.byte_length'
@@ -69,8 +68,8 @@ module data_view {
    return IsDetachedBuffer(view.buffer);
  }
-  macro ValidateDataView(context: Context,
+  macro ValidateDataView(
-      o: Object, method: String): JSDataView {
+      context: Context, o: Object, method: String): JSDataView {
    try {
      return Cast<JSDataView>(o) otherwise CastError;
    }
@@ -82,8 +81,8 @@ module data_view {
  // ES6 section 24.2.4.1 get DataView.prototype.buffer
  javascript builtin DataViewPrototypeGetBuffer(
      context: Context, receiver: Object, ...arguments): JSArrayBuffer {
-    let dataView: JSDataView = ValidateDataView(
+    let dataView: JSDataView =
-      context, receiver, 'get DataView.prototype.buffer');
+        ValidateDataView(context, receiver, 'get DataView.prototype.buffer');
    return dataView.buffer;
  }
@@ -123,8 +122,8 @@ module data_view {
  extern macro LoadUint8(RawPtr, uintptr): uint32;
  extern macro LoadInt8(RawPtr, uintptr): int32;
-  macro LoadDataView8(buffer: JSArrayBuffer, offset: uintptr,
+  macro LoadDataView8(
-                          signed: constexpr bool): Smi {
+      buffer: JSArrayBuffer, offset: uintptr, signed: constexpr bool): Smi {
    if constexpr (signed) {
      return Convert<Smi>(LoadInt8(buffer.backing_store, offset));
    } else {
@@ -132,8 +131,8 @@ module data_view {
    }
  }
-  macro LoadDataView16(buffer: JSArrayBuffer, offset: uintptr,
+  macro LoadDataView16(
-                       requestedLittleEndian: bool,
+      buffer: JSArrayBuffer, offset: uintptr, requestedLittleEndian: bool,
      signed: constexpr bool): Number {
    let dataPointer: RawPtr = buffer.backing_store;
@@ -159,8 +158,8 @@ module data_view {
    }
  }
-  macro LoadDataView32(buffer: JSArrayBuffer, offset: uintptr,
+  macro LoadDataView32(
-                       requestedLittleEndian: bool,
+      buffer: JSArrayBuffer, offset: uintptr, requestedLittleEndian: bool,
      kind: constexpr ElementsKind): Number {
    let dataPointer: RawPtr = buffer.backing_store;
@@ -188,7 +187,8 @@ module data_view {
    }
  }
-  macro LoadDataViewFloat64(buffer: JSArrayBuffer, offset: uintptr,
+  macro LoadDataViewFloat64(
+      buffer: JSArrayBuffer, offset: uintptr,
      requestedLittleEndian: bool): Number {
    let dataPointer: RawPtr = buffer.backing_store;
@@ -221,8 +221,8 @@ module data_view {
  extern macro AllocateBigInt(intptr): BigInt;
  extern macro StoreBigIntBitfield(BigInt, intptr): void;
  extern macro StoreBigIntDigit(BigInt, constexpr int31, uintptr): void;
-  extern macro DataViewEncodeBigIntBits(constexpr bool,
+  extern macro DataViewEncodeBigIntBits(
-      constexpr int31): intptr;
+      constexpr bool, constexpr int31): intptr;
  const kPositiveBigInt: constexpr bool = false;
  const kNegativeBigInt: constexpr bool = true;
@@ -236,20 +236,19 @@ module data_view {
    // Write the desired sign and length to the BigInt bitfield.
    if (isPositive) {
-      StoreBigIntBitfield(result,
+      StoreBigIntBitfield(
-          DataViewEncodeBigIntBits(kPositiveBigInt, length));
+          result, DataViewEncodeBigIntBits(kPositiveBigInt, length));
    } else {
-      StoreBigIntBitfield(result,
+      StoreBigIntBitfield(
-          DataViewEncodeBigIntBits(kNegativeBigInt, length));
+          result, DataViewEncodeBigIntBits(kNegativeBigInt, length));
    }
    return result;
  }
  // Create a BigInt on a 64-bit architecture from two 32-bit values.
-  macro MakeBigIntOn64Bit(lowWord: uint32, highWord: uint32,
+  macro MakeBigIntOn64Bit(
-                          signed: constexpr bool): BigInt {
+      lowWord: uint32, highWord: uint32, signed: constexpr bool): BigInt {
    // 0n is represented by a zero-length BigInt.
    if (lowWord == 0 && highWord == 0) {
      return AllocateBigInt(kZeroDigitBigInt);
@@ -277,9 +276,8 @@ module data_view {
  }
  // Create a BigInt on a 32-bit architecture from two 32-bit values.
-  macro MakeBigIntOn32Bit(lowWord: uint32, highWord: uint32,
+  macro MakeBigIntOn32Bit(
-                          signed: constexpr bool): BigInt {
+      lowWord: uint32, highWord: uint32, signed: constexpr bool): BigInt {
    // 0n is represented by a zero-length BigInt.
    if (lowWord == 0 && highWord == 0) {
      return AllocateBigInt(kZeroDigitBigInt);
@@ -299,7 +297,6 @@ module data_view {
    // Otherwise, all cases are possible.
    if (highWord != 0) {
      if constexpr (signed) {
        // If highPart < 0, the number is always negative.
        if (highPart < 0) {
          isPositive = false;
@@ -348,8 +345,8 @@ module data_view {
    return result;
  }
-  macro MakeBigInt(lowWord: uint32, highWord: uint32,
+  macro MakeBigInt(
-                   signed: constexpr bool): BigInt {
+      lowWord: uint32, highWord: uint32, signed: constexpr bool): BigInt {
    // A BigInt digit has the platform word size, so we only need one digit
    // on 64-bit platforms but may need two on 32-bit.
    if constexpr (Is64()) {
@@ -359,8 +356,8 @@ module data_view {
    }
  }
-  macro LoadDataViewBigInt(buffer: JSArrayBuffer, offset: uintptr,
+  macro LoadDataViewBigInt(
-                           requestedLittleEndian: bool,
+      buffer: JSArrayBuffer, offset: uintptr, requestedLittleEndian: bool,
      signed: constexpr bool): BigInt {
    let dataPointer: RawPtr = buffer.backing_store;
@@ -386,17 +383,15 @@ module data_view {
    return MakeBigInt(lowWord, highWord, signed);
  }
-  extern macro ToSmiIndex(Object, Context): Smi labels RangeError;
+  extern macro ToSmiIndex(Object, Context): Smi
+      labels RangeError;
  extern macro DataViewElementSize(constexpr ElementsKind): constexpr int31;
-  macro DataViewGet(context: Context,
+  macro DataViewGet(
-                    receiver: Object,
+      context: Context, receiver: Object, offset: Object,
-                    offset: Object,
+      requestedLittleEndian: Object, kind: constexpr ElementsKind): Numeric {
-                    requestedLittleEndian: Object,
+    let dataView: JSDataView =
-                    kind: constexpr ElementsKind): Numeric {
+        ValidateDataView(context, receiver, MakeDataViewGetterNameString(kind));
-    let dataView: JSDataView = ValidateDataView(
-        context, receiver, MakeDataViewGetterNameString(kind));
    let getIndex: Number;
    try {
@@ -410,8 +405,8 @@ module data_view {
    let buffer: JSArrayBuffer = dataView.buffer;
    if (IsDetachedBuffer(buffer)) {
-      ThrowTypeError(context, kDetachedOperation,
+      ThrowTypeError(
-                     MakeDataViewGetterNameString(kind));
+          context, kDetachedOperation, MakeDataViewGetterNameString(kind));
    }
    let getIndexFloat: float64 = Convert<float64>(getIndex);
@@ -454,114 +449,86 @@ module data_view {
  javascript builtin DataViewPrototypeGetUint8(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
-          Undefined;
    return DataViewGet(context, receiver, offset, Undefined, UINT8_ELEMENTS);
  }
  javascript builtin DataViewPrototypeGetInt8(
      context: Context, receiver: Object, ...arguments): Object {
-    let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-        arguments[0] :
-        Undefined;
    return DataViewGet(context, receiver, offset, Undefined, INT8_ELEMENTS);
  }
  javascript builtin DataViewPrototypeGetUint16(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let isLittleEndian: Object =
-          Undefined;
+        arguments.length > 1 ? arguments[1] : Undefined;
-      let isLittleEndian : Object = arguments.length > 1 ?
+    return DataViewGet(
-          arguments[1] :
+        context, receiver, offset, isLittleEndian, UINT16_ELEMENTS);
-          Undefined;
-      return DataViewGet(context, receiver, offset, isLittleEndian,
-                         UINT16_ELEMENTS);
  }
  javascript builtin DataViewPrototypeGetInt16(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let isLittleEndian: Object =
-          Undefined;
+        arguments.length > 1 ? arguments[1] : Undefined;
-      let isLittleEndian : Object = arguments.length > 1 ?
+    return DataViewGet(
-          arguments[1] :
+        context, receiver, offset, isLittleEndian, INT16_ELEMENTS);
-          Undefined;
-      return DataViewGet(context, receiver, offset, isLittleEndian,
-                         INT16_ELEMENTS);
  }
  javascript builtin DataViewPrototypeGetUint32(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let isLittleEndian: Object =
-          Undefined;
+        arguments.length > 1 ? arguments[1] : Undefined;
-      let isLittleEndian : Object = arguments.length > 1 ?
+    return DataViewGet(
-          arguments[1] :
+        context, receiver, offset, isLittleEndian, UINT32_ELEMENTS);
-          Undefined;
-      return DataViewGet(context, receiver, offset, isLittleEndian,
-                         UINT32_ELEMENTS);
  }
  javascript builtin DataViewPrototypeGetInt32(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let isLittleEndian: Object =
-          Undefined;
+        arguments.length > 1 ? arguments[1] : Undefined;
-      let isLittleEndian : Object = arguments.length > 1 ?
+    return DataViewGet(
-          arguments[1] :
+        context, receiver, offset, isLittleEndian, INT32_ELEMENTS);
-          Undefined;
-      return DataViewGet(context, receiver, offset, isLittleEndian,
-                         INT32_ELEMENTS);
  }
  javascript builtin DataViewPrototypeGetFloat32(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let isLittleEndian: Object =
-          Undefined;
+        arguments.length > 1 ? arguments[1] : Undefined;
-      let isLittleEndian : Object = arguments.length > 1 ?
+    return DataViewGet(
-          arguments[1] :
+        context, receiver, offset, isLittleEndian, FLOAT32_ELEMENTS);
-          Undefined;
-      return DataViewGet(context, receiver, offset, isLittleEndian,
-                         FLOAT32_ELEMENTS);
  }
  javascript builtin DataViewPrototypeGetFloat64(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let isLittleEndian: Object =
-          Undefined;
+        arguments.length > 1 ? arguments[1] : Undefined;
-      let isLittleEndian : Object = arguments.length > 1 ?
+    return DataViewGet(
-          arguments[1] :
+        context, receiver, offset, isLittleEndian, FLOAT64_ELEMENTS);
-          Undefined;
-      return DataViewGet(context, receiver, offset, isLittleEndian,
-                         FLOAT64_ELEMENTS);
  }
  javascript builtin DataViewPrototypeGetBigUint64(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let isLittleEndian: Object =
-          Undefined;
+        arguments.length > 1 ? arguments[1] : Undefined;
-      let isLittleEndian : Object = arguments.length > 1 ?
+    return DataViewGet(
-          arguments[1] :
+        context, receiver, offset, isLittleEndian, BIGUINT64_ELEMENTS);
-          Undefined;
-      return DataViewGet(context, receiver, offset, isLittleEndian,
-                         BIGUINT64_ELEMENTS);
  }
  javascript builtin DataViewPrototypeGetBigInt64(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let isLittleEndian: Object =
-          Undefined;
+        arguments.length > 1 ? arguments[1] : Undefined;
-      let isLittleEndian : Object = arguments.length > 1 ?
+    return DataViewGet(
-          arguments[1] :
+        context, receiver, offset, isLittleEndian, BIGINT64_ELEMENTS);
-          Undefined;
-      return DataViewGet(context, receiver, offset, isLittleEndian,
-                         BIGINT64_ELEMENTS);
  }
  extern macro ToNumber(Context, Object): Number;
@@ -571,12 +538,12 @@ module data_view {
  extern macro StoreWord8(RawPtr, uintptr, uint32): void;
-  macro StoreDataView8(buffer: JSArrayBuffer, offset: uintptr,
+  macro StoreDataView8(buffer: JSArrayBuffer, offset: uintptr, value: uint32) {
-                       value: uint32) {
    StoreWord8(buffer.backing_store, offset, value & 0xFF);
  }
-  macro StoreDataView16(buffer: JSArrayBuffer, offset: uintptr, value: uint32,
+  macro StoreDataView16(
+      buffer: JSArrayBuffer, offset: uintptr, value: uint32,
      requestedLittleEndian: bool) {
    let dataPointer: RawPtr = buffer.backing_store;
@@ -592,7 +559,8 @@ module data_view {
    }
  }
-  macro StoreDataView32(buffer: JSArrayBuffer, offset: uintptr, value: uint32,
+  macro StoreDataView32(
+      buffer: JSArrayBuffer, offset: uintptr, value: uint32,
      requestedLittleEndian: bool) {
    let dataPointer: RawPtr = buffer.backing_store;
@@ -614,8 +582,8 @@ module data_view {
    }
  }
-  macro StoreDataView64(buffer: JSArrayBuffer, offset: uintptr,
+  macro StoreDataView64(
-                        lowWord: uint32, highWord: uint32,
+      buffer: JSArrayBuffer, offset: uintptr, lowWord: uint32, highWord: uint32,
      requestedLittleEndian: bool) {
    let dataPointer: RawPtr = buffer.backing_store;
@@ -629,7 +597,6 @@ module data_view {
    let b6: uint32 = (highWord >>> 16) & 0xFF;
    let b7: uint32 = highWord >>> 24;
    if (requestedLittleEndian) {
      StoreWord8(dataPointer, offset, b0);
      StoreWord8(dataPointer, offset + 1, b1);
@@ -658,10 +625,9 @@ module data_view {
  // We might get here a BigInt that is bigger than 64 bits, but we're only
  // interested in the 64 lowest ones. This means the lowest BigInt digit
  // on 64-bit platforms, and the 2 lowest BigInt digits on 32-bit ones.
-  macro StoreDataViewBigInt(buffer: JSArrayBuffer, offset: uintptr,
+  macro StoreDataViewBigInt(
-                            bigIntValue: BigInt,
+      buffer: JSArrayBuffer, offset: uintptr, bigIntValue: BigInt,
      requestedLittleEndian: bool) {
    let length: uintptr = DataViewDecodeBigIntLength(bigIntValue);
    let sign: uintptr = DataViewDecodeBigIntSign(bigIntValue);
@@ -677,8 +643,7 @@ module data_view {
        let value: uintptr = LoadBigIntDigit(bigIntValue, 0);
        lowWord = Convert<uint32>(value);  // Truncates value to 32 bits.
        highWord = Convert<uint32>(value >>> 32);
-      }
+      } else {  // There might be either 1 or 2 BigInt digits we need to load.
-      else { // There might be either 1 or 2 BigInt digits we need to load.
        lowWord = Convert<uint32>(LoadBigIntDigit(bigIntValue, 0));
        if (length >= 2) {  // Only load the second digit if there is one.
          highWord = Convert<uint32>(LoadBigIntDigit(bigIntValue, 1));
@@ -694,19 +659,14 @@ module data_view {
      lowWord = Unsigned(0 - Signed(lowWord));
    }
-    StoreDataView64(buffer, offset, lowWord, highWord,
+    StoreDataView64(buffer, offset, lowWord, highWord, requestedLittleEndian);
-                    requestedLittleEndian);
  }
-  macro DataViewSet(context: Context,
+  macro DataViewSet(
-                    receiver: Object,
+      context: Context, receiver: Object, offset: Object, value: Object,
-                    offset: Object,
+      requestedLittleEndian: Object, kind: constexpr ElementsKind): Object {
-                    value: Object,
+    let dataView: JSDataView =
-                    requestedLittleEndian: Object,
+        ValidateDataView(context, receiver, MakeDataViewSetterNameString(kind));
-                    kind: constexpr ElementsKind): Object {
-    let dataView: JSDataView = ValidateDataView(
-        context, receiver, MakeDataViewSetterNameString(kind));
    let getIndex: Number;
    try {
@@ -730,8 +690,8 @@ module data_view {
    }
    if (IsDetachedBuffer(buffer)) {
-      ThrowTypeError(context, kDetachedOperation,
+      ThrowTypeError(
-                     MakeDataViewSetterNameString(kind));
+          context, kDetachedOperation, MakeDataViewSetterNameString(kind));
    }
    let getIndexFloat: float64 = Convert<float64>(getIndex);
@@ -748,34 +708,30 @@ module data_view {
    let bufferIndex: uintptr = getIndexWord + viewOffsetWord;
    if constexpr (kind == BIGUINT64_ELEMENTS || kind == BIGINT64_ELEMENTS) {
-      StoreDataViewBigInt(buffer, bufferIndex, bigIntValue,
+      StoreDataViewBigInt(buffer, bufferIndex, bigIntValue, littleEndian);
-                          littleEndian);
+    } else {
-    }
-    else {
      let doubleValue: float64 = ChangeNumberToFloat64(numValue);
      if constexpr (kind == UINT8_ELEMENTS || kind == INT8_ELEMENTS) {
-        StoreDataView8(buffer, bufferIndex,
+        StoreDataView8(
-                      TruncateFloat64ToWord32(doubleValue));
+            buffer, bufferIndex, TruncateFloat64ToWord32(doubleValue));
-      }
+      } else if constexpr (kind == UINT16_ELEMENTS || kind == INT16_ELEMENTS) {
-      else if constexpr (kind == UINT16_ELEMENTS || kind == INT16_ELEMENTS) {
+        StoreDataView16(
-        StoreDataView16(buffer, bufferIndex,
+            buffer, bufferIndex, TruncateFloat64ToWord32(doubleValue),
-                        TruncateFloat64ToWord32(doubleValue), littleEndian);
+            littleEndian);
-      }
+      } else if constexpr (kind == UINT32_ELEMENTS || kind == INT32_ELEMENTS) {
-      else if constexpr (kind == UINT32_ELEMENTS || kind == INT32_ELEMENTS) {
+        StoreDataView32(
-        StoreDataView32(buffer, bufferIndex,
+            buffer, bufferIndex, TruncateFloat64ToWord32(doubleValue),
-                        TruncateFloat64ToWord32(doubleValue), littleEndian);
+            littleEndian);
-      }
+      } else if constexpr (kind == FLOAT32_ELEMENTS) {
-      else if constexpr (kind == FLOAT32_ELEMENTS) {
        let floatValue: float32 = TruncateFloat64ToFloat32(doubleValue);
-        StoreDataView32(buffer, bufferIndex,
+        StoreDataView32(
-                        BitcastFloat32ToInt32(floatValue), littleEndian);
+            buffer, bufferIndex, BitcastFloat32ToInt32(floatValue),
-      }
+            littleEndian);
-      else if constexpr (kind == FLOAT64_ELEMENTS) {
+      } else if constexpr (kind == FLOAT64_ELEMENTS) {
        let lowWord: uint32 = Float64ExtractLowWord32(doubleValue);
        let highWord: uint32 = Float64ExtractHighWord32(doubleValue);
-        StoreDataView64(buffer, bufferIndex, lowWord, highWord,
+        StoreDataView64(buffer, bufferIndex, lowWord, highWord, littleEndian);
-                        littleEndian);
      }
    }
    return Undefined;
@@ -783,146 +739,97 @@ module data_view {
  javascript builtin DataViewPrototypeSetUint8(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
-          Undefined;
+    return DataViewSet(
-      let value : Object = arguments.length > 1 ?
+        context, receiver, offset, value, Undefined, UINT8_ELEMENTS);
-          arguments[1] :
-          Undefined;
-      return DataViewSet(context, receiver, offset, value, Undefined,
-                         UINT8_ELEMENTS);
  }
  javascript builtin DataViewPrototypeSetInt8(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
-          Undefined;
+    return DataViewSet(
-      let value : Object = arguments.length > 1 ?
+        context, receiver, offset, value, Undefined, INT8_ELEMENTS);
-          arguments[1] :
-          Undefined;
-      return DataViewSet(context, receiver, offset, value, Undefined,
-                         INT8_ELEMENTS);
  }
  javascript builtin DataViewPrototypeSetUint16(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
-          Undefined;
+    let isLittleEndian: Object =
-      let value : Object = arguments.length > 1 ?
+        arguments.length > 2 ? arguments[2] : Undefined;
-          arguments[1] :
+    return DataViewSet(
-          Undefined;
+        context, receiver, offset, value, isLittleEndian, UINT16_ELEMENTS);
-      let isLittleEndian : Object = arguments.length > 2 ?
-          arguments[2] :
-          Undefined;
-      return DataViewSet(context, receiver, offset, value,
-                         isLittleEndian, UINT16_ELEMENTS);
  }
  javascript builtin DataViewPrototypeSetInt16(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
-          Undefined;
+    let isLittleEndian: Object =
-      let value : Object = arguments.length > 1 ?
+        arguments.length > 2 ? arguments[2] : Undefined;
-          arguments[1] :
+    return DataViewSet(
-          Undefined;
+        context, receiver, offset, value, isLittleEndian, INT16_ELEMENTS);
-      let isLittleEndian : Object = arguments.length > 2 ?
-          arguments[2] :
-          Undefined;
-      return DataViewSet(context, receiver, offset, value,
-                         isLittleEndian, INT16_ELEMENTS);
  }
  javascript builtin DataViewPrototypeSetUint32(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
-          Undefined;
+    let isLittleEndian: Object =
-      let value : Object = arguments.length > 1 ?
+        arguments.length > 2 ? arguments[2] : Undefined;
-          arguments[1] :
+    return DataViewSet(
-          Undefined;
+        context, receiver, offset, value, isLittleEndian, UINT32_ELEMENTS);
-      let isLittleEndian : Object = arguments.length > 2 ?
-          arguments[2] :
-          Undefined;
-      return DataViewSet(context, receiver, offset, value,
-                         isLittleEndian, UINT32_ELEMENTS);
  }
  javascript builtin DataViewPrototypeSetInt32(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
-          Undefined;
+    let isLittleEndian: Object =
-      let value : Object = arguments.length > 1 ?
+        arguments.length > 2 ? arguments[2] : Undefined;
-          arguments[1] :
+    return DataViewSet(
-          Undefined;
+        context, receiver, offset, value, isLittleEndian, INT32_ELEMENTS);
-      let isLittleEndian : Object = arguments.length > 2 ?
-          arguments[2] :
-          Undefined;
-      return DataViewSet(context, receiver, offset, value,
-                         isLittleEndian, INT32_ELEMENTS);
  }
  javascript builtin DataViewPrototypeSetFloat32(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
-          Undefined;
+    let isLittleEndian: Object =
-      let value : Object = arguments.length > 1 ?
+        arguments.length > 2 ? arguments[2] : Undefined;
-          arguments[1] :
+    return DataViewSet(
-          Undefined;
+        context, receiver, offset, value, isLittleEndian, FLOAT32_ELEMENTS);
-      let isLittleEndian : Object = arguments.length > 2 ?
-          arguments[2] :
-          Undefined;
-      return DataViewSet(context, receiver, offset, value,
-                         isLittleEndian, FLOAT32_ELEMENTS);
  }
  javascript builtin DataViewPrototypeSetFloat64(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
-          Undefined;
+    let isLittleEndian: Object =
-      let value : Object = arguments.length > 1 ?
+        arguments.length > 2 ? arguments[2] : Undefined;
-          arguments[1] :
+    return DataViewSet(
-          Undefined;
+        context, receiver, offset, value, isLittleEndian, FLOAT64_ELEMENTS);
-      let isLittleEndian : Object = arguments.length > 2 ?
-          arguments[2] :
-          Undefined;
-      return DataViewSet(context, receiver, offset, value,
-                         isLittleEndian, FLOAT64_ELEMENTS);
  }
  javascript builtin DataViewPrototypeSetBigUint64(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
-          Undefined;
+    let isLittleEndian: Object =
-      let value : Object = arguments.length > 1 ?
+        arguments.length > 2 ? arguments[2] : Undefined;
-          arguments[1] :
+    return DataViewSet(
-          Undefined;
+        context, receiver, offset, value, isLittleEndian, BIGUINT64_ELEMENTS);
-      let isLittleEndian : Object = arguments.length > 2 ?
-          arguments[2] :
-          Undefined;
-      return DataViewSet(context, receiver, offset, value,
-                         isLittleEndian, BIGUINT64_ELEMENTS);
  }
  javascript builtin DataViewPrototypeSetBigInt64(
      context: Context, receiver: Object, ...arguments): Object {
-      let offset: Object = arguments.length > 0 ?
+    let offset: Object = arguments.length > 0 ? arguments[0] : Undefined;
-          arguments[0] :
+    let value: Object = arguments.length > 1 ? arguments[1] : Undefined;
-          Undefined;
+    let isLittleEndian: Object =
-      let value : Object = arguments.length > 1 ?
+        arguments.length > 2 ? arguments[2] : Undefined;
-          arguments[1] :
+    return DataViewSet(
-          Undefined;
+        context, receiver, offset, value, isLittleEndian, BIGINT64_ELEMENTS);
-      let isLittleEndian : Object = arguments.length > 2 ?
-          arguments[2] :
-          Undefined;
-      return DataViewSet(context, receiver, offset, value,
-                         isLittleEndian, BIGINT64_ELEMENTS);
  }
 }
--- a/src/torque/torque-parser.cc
+++ b/src/torque/torque-parser.cc
@@ -1265,7 +1265,7 @@ struct TorqueGrammar : Grammar {
  Symbol typeswitchCase = {
      Rule({Token("case"), Token("("),
            Optional<std::string>(Sequence({&identifier, Token(":")})), &type,
-            Token(")"), &block},
+            Token(")"), Token(":"), &block},
           MakeTypeswitchCase)};
  // Result: base::Optional<Statement*>

--- a/test/torque/test-torque.tq
+++ b/test/torque/test-torque.tq
@@ -4,10 +4,9 @@
 module test {
  macro ElementsKindTestHelper1(kind: constexpr ElementsKind): bool {
-    if constexpr((kind == UINT8_ELEMENTS) || (kind == UINT16_ELEMENTS)) {
+    if constexpr ((kind == UINT8_ELEMENTS) || (kind == UINT16_ELEMENTS)) {
      return true;
-      }
+    } else {
-    else {
      return false;
    }
  }
@@ -82,7 +81,7 @@ module test {
    }
  }
-  builtin GenericBuiltinTest<T : type>(c: Context, param: T): Object {
+  builtin GenericBuiltinTest<T: type>(c: Context, param: T): Object {
    return Null;
  }
@@ -97,8 +96,9 @@ module test {
    check(GenericBuiltinTest<Object>(c, Undefined) == Undefined);
  }
-  macro LabelTestHelper4(flag: constexpr bool): never labels Label4, Label5 {
+  macro LabelTestHelper4(flag: constexpr bool): never
-    if constexpr(flag) {
+      labels Label4, Label5 {
+    if constexpr (flag) {
      goto Label4;
    } else {
      goto Label5;
@@ -128,7 +128,7 @@ module test {
    }
  }
-  macro GenericMacroTest<T : type>(param: T): Object {
+  macro GenericMacroTest<T: type>(param: T): Object {
    return Undefined;
  }
@@ -136,11 +136,13 @@ module test {
    return param2;
  }
-  macro GenericMacroTestWithLabels<T : type>(param: T): Object labels X {
+  macro GenericMacroTestWithLabels<T: type>(param: T): Object
+      labels X {
    return Undefined;
  }
-  GenericMacroTestWithLabels<Object>(param2: Object): Object labels Y {
+  GenericMacroTestWithLabels<Object>(param2: Object): Object
+      labels Y {
    return param2;
  }
@@ -244,12 +246,12 @@ module test {
  }
  macro TestLocalConstBindings() {
-    const x : constexpr int31 = 3;
+    const x: constexpr int31 = 3;
-    const xSmi : Smi = x;
+    const xSmi: Smi = x;
    {
-      const x : Smi = x + FromConstexpr<Smi>(1);
+      const x: Smi = x + FromConstexpr<Smi>(1);
      check(x == xSmi + 1);
-      const xSmi : Smi = x;
+      const xSmi: Smi = x;
      check(x == xSmi);
      check(x == 4);
    }
@@ -287,14 +289,15 @@ module test {
    d.x = a;
    d = TestStructB{a, 7};
    let e: TestStructA = d.x;
-    let f: Smi = TestStructA{UnsafeCast<FixedArray>(kEmptyFixedArray), 27, 31}.i;
+    let f: Smi =
+    TestStructA{UnsafeCast<FixedArray>(kEmptyFixedArray), 27, 31}.i;
    f = TestStruct2().i;
    return a;
  }
  struct TestStructC {
-    x : TestStructA;
+    x: TestStructA;
-    y : TestStructA;
+    y: TestStructA;
  }
  macro TestStruct4(): TestStructC {
@@ -387,38 +390,42 @@ module test {
    check(sum == 7);
  }
-  macro TestSubtyping(x : Smi) {
+  macro TestSubtyping(x: Smi) {
-    const foo : Object = x;
+    const foo: Object = x;
  }
-  macro IncrementIfSmi<A : type>(x : A) : A {
+  macro IncrementIfSmi<A: type>(x: A): A {
    typeswitch (x) {
-      case (x : Smi) {
+      case (x: Smi): {
        return x + 1;
-      } case (o : A) {
+      }
+      case (o: A): {
        return o;
      }
    }
  }
-  macro TypeswitchExample(x : Number | FixedArray) : int32 {
+  macro TypeswitchExample(x: Number | FixedArray): int32 {
-    let result : int32 = 0;
+    let result: int32 = 0;
-    typeswitch (IncrementIfSmi<(Number|FixedArray)>(x)) {
+    typeswitch (IncrementIfSmi<(Number | FixedArray)>(x)) {
-      case (x : FixedArray) {
+      case (x: FixedArray): {
        result = result + 1;
-      } case (Number) {
+      }
+      case (Number): {
        result = result + 2;
      }
    }
    result = result * 10;
-    typeswitch (IncrementIfSmi<(Number|FixedArray)>(x)) {
+    typeswitch (IncrementIfSmi<(Number | FixedArray)>(x)) {
-      case (x : Smi) {
+      case (x: Smi): {
        result = result + Convert<int32>(x);
-      } case (a : FixedArray) {
+      }
+      case (a: FixedArray): {
        result = result + Convert<int32>(a.length);
-      } case (x : HeapNumber) {
+      }
+      case (x: HeapNumber): {
        result = result + 7;
      }
    }
@@ -428,26 +435,27 @@ module test {
  macro TestTypeswitch() {
    check(TypeswitchExample(FromConstexpr<Smi>(5)) == 26);
-    const a : FixedArray = AllocateZeroedFixedArray(3);
+    const a: FixedArray = AllocateZeroedFixedArray(3);
    check(TypeswitchExample(a) == 13);
    check(TypeswitchExample(FromConstexpr<Number>(0.5)) == 27);
  }
-  macro ExampleGenericOverload<A: type>(o : Object) : A {
+  macro ExampleGenericOverload<A: type>(o: Object): A {
    return o;
  }
-  macro ExampleGenericOverload<A: type>(o : Smi) : A {
+  macro ExampleGenericOverload<A: type>(o: Smi): A {
    return o + 1;
  }
  macro TestGenericOverload() {
-    const xSmi : Smi = 5;
+    const xSmi: Smi = 5;
-    const xObject : Object = xSmi;
+    const xObject: Object = xSmi;
    check(ExampleGenericOverload<Smi>(xSmi) == 6);
    check(UnsafeCast<Smi>(ExampleGenericOverload<Object>(xObject)) == 5);
  }
-  macro BoolToBranch(x : bool) : never labels Taken, NotTaken {
+  macro BoolToBranch(x: bool): never
+      labels Taken, NotTaken {
    if (x) {
      goto Taken;
    } else {
@@ -455,27 +463,27 @@ module test {
    }
  }
-  macro TestOrAnd1(x : bool, y : bool, z : bool) : bool {
+  macro TestOrAnd1(x: bool, y: bool, z: bool): bool {
    return BoolToBranch(x) || y && z ? true : false;
  }
-  macro TestOrAnd2(x : bool, y : bool, z : bool) : bool {
+  macro TestOrAnd2(x: bool, y: bool, z: bool): bool {
    return x || BoolToBranch(y) && z ? true : false;
  }
-  macro TestOrAnd3(x : bool, y : bool, z : bool) : bool {
+  macro TestOrAnd3(x: bool, y: bool, z: bool): bool {
    return x || y && BoolToBranch(z) ? true : false;
  }
-  macro TestAndOr1(x : bool, y : bool, z : bool) : bool {
+  macro TestAndOr1(x: bool, y: bool, z: bool): bool {
    return BoolToBranch(x) && y || z ? true : false;
  }
-  macro TestAndOr2(x : bool, y : bool, z : bool) : bool {
+  macro TestAndOr2(x: bool, y: bool, z: bool): bool {
    return x && BoolToBranch(y) || z ? true : false;
  }
-  macro TestAndOr3(x : bool, y : bool, z : bool) : bool {
+  macro TestAndOr3(x: bool, y: bool, z: bool): bool {
    return x && y || BoolToBranch(z) ? true : false;
  }
@@ -529,5 +537,4 @@ module test {
    check(!TestOrAnd2(false, false, false));
    check(!TestOrAnd3(false, false, false));
  }
 }
--- a/third_party/v8/builtins/array-sort.tq
+++ b/third_party/v8/builtins/array-sort.tq
@@ -124,7 +124,7 @@ module array {
  // copied values from the prototype chain to the receiver if they were visible
  // through a hole.
-  builtin Load<ElementsAccessor : type>(
+  builtin Load<ElementsAccessor: type>(
      context: Context, sortState: FixedArray, elements: HeapObject,
      index: Smi): Object {
    return GetProperty(context, elements, index);
@@ -193,7 +193,7 @@ module array {
    return elems[index];
  }
-  builtin Store<ElementsAccessor : type>(
+  builtin Store<ElementsAccessor: type>(
      context: Context, sortState: FixedArray, elements: HeapObject, index: Smi,
      value: Object): Smi {
    SetProperty(context, elements, index, value);
@@ -230,8 +230,7 @@ module array {
  Store<DictionaryElements>(
      context: Context, sortState: FixedArray, elements: HeapObject, index: Smi,
      value: Object): Smi {
-    const dictionary: NumberDictionary =
+    const dictionary: NumberDictionary = UnsafeCast<NumberDictionary>(elements);
-        UnsafeCast<NumberDictionary>(elements);
    const intptrIndex: intptr = Convert<intptr>(index);
    try {
      BasicStoreNumberDictionaryElement(dictionary, intptrIndex, value)
@@ -323,7 +322,7 @@ module array {
    return v;
  }
-  builtin CanUseSameAccessor<ElementsAccessor : type>(
+  builtin CanUseSameAccessor<ElementsAccessor: type>(
      context: Context, receiver: JSReceiver, initialReceiverMap: Object,
      initialReceiverLength: Number): Boolean {
    assert(IsJSArray(receiver));
@@ -488,7 +487,8 @@ module array {
  macro CallLoad(
      context: Context, sortState: FixedArray, load: LoadFn,
-      elements: HeapObject, index: Smi): Object labels Bailout {
+      elements: HeapObject, index: Smi): Object
+      labels Bailout {
    const result: Object = load(context, sortState, elements, index);
    EnsureSuccess(sortState) otherwise Bailout;
    return result;
@@ -751,10 +751,10 @@ module array {
    let runLength: Smi = 2;
-    const elementLow: Object =
+    const elementLow: Object = CallLoad(
-        CallLoad(context, sortState, load, elements, low) otherwise Bailout;
+        context, sortState, load, elements, low) otherwise Bailout;
-    const elementLowPred: Object =
+    const elementLowPred: Object = CallLoad(
-        CallLoad(context, sortState, load, elements, low - 1) otherwise Bailout;
+        context, sortState, load, elements, low - 1) otherwise Bailout;
    let order: Number =
        CallCompareFn(context, sortState, elementLow, elementLowPred)
        otherwise Bailout;
@@ -767,8 +767,8 @@ module array {
    let previousElement: Object = elementLow;
    for (let idx: Smi = low + 1; idx < high; ++idx) {
-      const currentElement: Object =
+      const currentElement: Object = CallLoad(
-          CallLoad(context, sortState, load, elements, idx) otherwise Bailout;
+          context, sortState, load, elements, idx) otherwise Bailout;
      order = CallCompareFn(context, sortState, currentElement, previousElement)
          otherwise Bailout;
      elements = ReloadElements(sortState);
@@ -800,10 +800,10 @@ module array {
    let high: Smi = to - 1;
    while (low < high) {
-      const elementLow: Object =
+      const elementLow: Object = CallLoad(
-          CallLoad(context, sortState, load, elements, low) otherwise Bailout;
+          context, sortState, load, elements, low) otherwise Bailout;
-      const elementHigh: Object =
+      const elementHigh: Object = CallLoad(
-          CallLoad(context, sortState, load, elements, high) otherwise Bailout;
+          context, sortState, load, elements, high) otherwise Bailout;
      CallStore(context, sortState, store, elements, low++, elementHigh)
          otherwise Bailout;
      CallStore(context, sortState, store, elements, high--, elementLow)
@@ -1632,7 +1632,7 @@ module array {
    sortState[kPendingRunsIdx] = pendingRuns;
  }
-  macro InitializeSortStateAccessor<Accessor : type>(sortState: FixedArray) {
+  macro InitializeSortStateAccessor<Accessor: type>(sortState: FixedArray) {
    sortState[kAccessorIdx] = kFastElementsAccessorId;
    sortState[kLoadFnIdx] = Load<Accessor>;
    sortState[kStoreFnIdx] = Store<Accessor>;

--- a/tools/torque/format-torque.py
+++ b/tools/torque/format-torque.py
@@ -11,6 +11,42 @@ import sys
 import re
 from subprocess import Popen, PIPE
+def preprocess(input):
+  input = re.sub(r'(if\s+)constexpr(\s*\()', r'\1/*COxp*/\2', input)
+  input = re.sub(r'(\)\s*\:\s*\S+\s+)labels\s+',
+      r'\1,\n/*_LABELS_HOLD_*/ ', input)
+  input = re.sub(r'(\s+)operator\s*(\'[^\']+\')', r'\1/*_OPE \2*/', input)
+  input = re.sub(r'(\s+)typeswitch\s*\(', r'\1/*_TYPE*/switch (', input)
+  input = re.sub(r'(\s+)case\s*\(([^\s]+)\s+\:\s*([^\:]+)\)(\s*)\:',
+      r'\1case \3: /*_TSV\2:*/', input)
+  input = re.sub(r'(\s+)case\s*\(([^\:]+)\)(\s*)\:',
+      r'\1case \2: /*_TSX*/', input)
+  input = re.sub(r'\sgenerates\s+\'([^\']+)\'\s*',
+      r' _GeNeRaT_/*\1@*/', input)
+  input = re.sub(r'\sconstexpr\s+\'([^\']+)\'\s*',
+      r' _CoNsExP_/*\1@*/', input)
+  return input
+def postprocess(output):
+  output = re.sub(r'\/\*COxp\*\/', r'constexpr', output)
+  output = re.sub(r'(\S+)\s*: type([,>])', r'\1: type\2', output)
+  output = re.sub(r',([\n ]*)\/\*_LABELS_HOLD_\*\/', r'\1labels', output)
+  output = re.sub(r'\/\*_OPE \'([^\']+)\'\*\/', r"operator '\1'", output)
+  output = re.sub(r'\/\*_TYPE\*\/(\s*)switch', r'typeswitch', output)
+  output = re.sub(r'case ([^\:]+)\:\s*\/\*_TSX\*\/',
+      r'case (\1):', output)
+  output = re.sub(r'case ([^\:]+)\:\s*\/\*_TSV([^\:]+)\:\*\/',
+      r'case (\2: \1):', output)
+  output = re.sub(r'(\n\s*)_GeNeRaT_\s*\/\*([^@]+)@\*\/',
+      r"\1    generates '\2'", output)
+  output = re.sub(r'_GeNeRaT_\s*\/\*([^@]+)@\*\/',
+      r"generates '\1'", output)
+  output = re.sub(r'_CoNsExP_\s*\/\*([^@]+)@\*\/',
+      r"constexpr '\1'", output)
+  output = re.sub(r'(\n\s*)otherwise(\s+\S+\s*[\(\;])',
+      r"\1    otherwise\2", output)
+  return output
 if len(sys.argv) < 2 or len(sys.argv) > 3:
  print "invalid number of arguments"
  sys.exit(-1)
@@ -24,7 +60,8 @@ filename = sys.argv[len(sys.argv) - 1]
 with open(filename, 'r') as content_file:
  content = content_file.read()
 p = Popen(['clang-format', '-assume-filename=.ts'], stdin=PIPE, stdout=PIPE, stderr=PIPE)
-output, err = p.communicate(content)
+output, err = p.communicate(preprocess(content))
+output = postprocess(output)
 rc = p.returncode
 if (rc <> 0):
  sys.exit(rc);