refactor(all): remove binding pattern wierdness

Author: camc314

apps/oxlint/src-js/generated/deserialize.js

@@ -1592,24 +1592,34 @@ function deserializeVariableDeclarationKind(pos) {
 }
 
 function deserializeVariableDeclarator(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    previousParent = parent,
-    node = (parent = {
+  let previousParent = parent,
+    variableDeclarator = (parent = {
       __proto__: NodeProto,
       type: 'VariableDeclarator',
       id: null,
       init: null,
-      definite: deserializeBool(pos + 57),
-      start,
-      end,
-      range: [start, end],
-      parent,
+      definite: false,
+      start: deserializeU32(pos),
+      end: deserializeU32(pos + 4),
+      range: [deserializeU32(pos), deserializeU32(pos + 4)],
+      parent: previousParent,
     });
-  node.id = deserializeBindingPattern(pos + 8);
-  node.init = deserializeOptionExpression(pos + 40);
+  variableDeclarator.id = deserializeBindingPattern(pos + 8);
+  {
+    parent = variableDeclarator.id;
+    let typeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 24);
+    variableDeclarator.id.typeAnnotation = typeAnnotation;
+    // Extend id span to include type annotation
+    if (typeAnnotation !== null) {
+      variableDeclarator.id.end = typeAnnotation.end;
+      variableDeclarator.id.range[1] = typeAnnotation.end;
+    }
+    parent = variableDeclarator;
+    variableDeclarator.definite = deserializeBool(pos + 49);
+  }
+  variableDeclarator.init = deserializeOptionExpression(pos + 32);
   parent = previousParent;
-  return node;
+  return variableDeclarator;
 }
 
 function deserializeEmptyStatement(pos) {
@@ -2088,13 +2098,26 @@ function deserializeCatchClause(pos) {
       parent,
     });
   node.param = deserializeOptionCatchParameter(pos + 8);
-  node.body = deserializeBoxBlockStatement(pos + 48);
+  node.body = deserializeBoxBlockStatement(pos + 40);
   parent = previousParent;
   return node;
 }
 
 function deserializeCatchParameter(pos) {
-  return deserializeBindingPattern(pos + 8);
+  let previousParent = parent,
+    pattern = deserializeBindingPattern(pos + 8);
+  {
+    parent = pattern;
+    let typeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 24);
+    pattern.typeAnnotation = typeAnnotation;
+    // Extend pattern span to include type annotation
+    if (typeAnnotation !== null) {
+      pattern.end = typeAnnotation.end;
+      pattern.range[1] = typeAnnotation.end;
+    }
+    parent = previousParent;
+  }
+  return pattern;
 }
 
 function deserializeDebuggerStatement(pos) {
@@ -2111,18 +2134,6 @@ function deserializeDebuggerStatement(pos) {
 }
 
 function deserializeBindingPattern(pos) {
-  let pattern = deserializeBindingPatternKind(pos);
-  {
-    let previousParent = parent;
-    parent = pattern;
-    pattern.optional = deserializeBool(pos + 24);
-    pattern.typeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 16);
-    parent = previousParent;
-  }
-  return pattern;
-}
-
-function deserializeBindingPatternKind(pos) {
   switch (uint8[pos]) {
     case 0:
       return deserializeBoxBindingIdentifier(pos + 8);
@@ -2133,7 +2144,7 @@ function deserializeBindingPatternKind(pos) {
     case 3:
       return deserializeBoxAssignmentPattern(pos + 8);
     default:
-      throw Error(`Unexpected discriminant ${uint8[pos]} for BindingPatternKind`);
+      throw Error(`Unexpected discriminant ${uint8[pos]} for BindingPattern`);
   }
 }
 
@@ -2156,7 +2167,7 @@ function deserializeAssignmentPattern(pos) {
     });
   node.decorators = [];
   node.left = deserializeBindingPattern(pos + 8);
-  node.right = deserializeExpression(pos + 40);
+  node.right = deserializeExpression(pos + 24);
   node.optional = false;
   parent = previousParent;
   return node;
@@ -2199,8 +2210,8 @@ function deserializeBindingProperty(pos) {
       key: null,
       value: null,
       method: null,
-      shorthand: deserializeBool(pos + 56),
-      computed: deserializeBool(pos + 57),
+      shorthand: deserializeBool(pos + 40),
+      computed: deserializeBool(pos + 41),
       optional: null,
       start,
       end,
@@ -2329,34 +2340,86 @@ function deserializeFormalParameters(pos) {
         type: 'RestElement',
         decorators: [],
         argument: null,
-        optional: deserializeBool(pos + 32),
+        optional: false,
         typeAnnotation: null,
         value: null,
-        start: (start = deserializeU32(pos)),
-        end: (end = deserializeU32(pos + 4)),
+        start: (start = deserializeU32(pos + 8)),
+        end: (end = deserializeU32(pos + 12)),
         range: [start, end],
-        parent,
+        parent: previousParent,
       });
-    rest.argument = deserializeBindingPatternKind(pos + 8);
-    rest.typeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 24);
+    rest.argument = deserializeBindingPattern(pos + 16);
+    rest.typeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 32);
+    // If there's a type annotation, extend the end to include it
+    if (rest.typeAnnotation !== null) {
+      end = rest.typeAnnotation.end;
+      rest.end = end;
+      rest.range[1] = end;
+    }
     params.push(rest);
     parent = previousParent;
   }
   return params;
 }
 
 function deserializeFormalParameter(pos) {
-  let param;
+  let param,
+    previousParent = parent,
+    hasInitializer = uint32[(pos + 56) >> 2] !== 0 && uint32[(pos + 60) >> 2] !== 0;
   {
-    let accessibility = deserializeOptionTSAccessibility(pos + 64),
-      readonly = deserializeBool(pos + 65),
-      override = deserializeBool(pos + 66),
-      previousParent = parent;
+    let accessibility = deserializeOptionTSAccessibility(pos + 65),
+      readonly = deserializeBool(pos + 66),
+      override = deserializeBool(pos + 67);
     if (accessibility === null && !readonly && !override) {
-      param = parent = deserializeBindingPatternKind(pos + 32);
-      param.decorators = deserializeVecDecorator(pos + 8);
-      param.optional = deserializeBool(pos + 56);
-      param.typeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 48);
+      let optional = deserializeBool(pos + 64);
+      if (hasInitializer) {
+        let start, end;
+        param = parent = {
+          __proto__: NodeProto,
+          type: 'AssignmentPattern',
+          decorators: null,
+          left: null,
+          right: null,
+          optional,
+          typeAnnotation: null,
+          start: (start = deserializeU32(pos)),
+          end: (end = deserializeU32(pos + 4)),
+          range: [start, end],
+          parent: previousParent,
+        };
+        param.decorators = deserializeVecDecorator(pos + 8);
+        param.left = deserializeBindingPattern(pos + 32);
+        param.left.decorators = [];
+        param.left.optional = false;
+        parent = param.left;
+        let leftTypeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 48);
+        param.left.typeAnnotation = leftTypeAnnotation;
+        // Extend left span to include type annotation
+        if (leftTypeAnnotation !== null) {
+          param.left.end = leftTypeAnnotation.end;
+          param.left.range[1] = leftTypeAnnotation.end;
+        }
+        parent = param;
+        param.right = deserializeOptionBoxExpression(pos + 56);
+      } else {
+        param = deserializeBindingPattern(pos + 32);
+        param.parent = previousParent;
+        parent = param;
+        param.decorators = deserializeVecDecorator(pos + 8);
+        param.optional = optional;
+        let typeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 48);
+        param.typeAnnotation = typeAnnotation;
+        // Extend param span to include type annotation or optional marker
+        if (typeAnnotation !== null) {
+          param.end = typeAnnotation.end;
+          param.range[1] = typeAnnotation.end;
+        } else if (optional) {
+          // Optional marker '?' is included in FormalParameter span
+          param.end = deserializeU32(pos + 4);
+          param.range[1] = deserializeU32(pos + 4);
+        }
+        parent = previousParent;
+      }
     } else {
       let start, end;
       param = parent = {
@@ -2371,13 +2434,67 @@ function deserializeFormalParameter(pos) {
         start: (start = deserializeU32(pos)),
         end: (end = deserializeU32(pos + 4)),
         range: [start, end],
-        parent,
+        parent: previousParent,
       };
       param.decorators = deserializeVecDecorator(pos + 8);
-      param.parameter = deserializeBindingPattern(pos + 32);
+      if (hasInitializer) {
+        // Wrap in AssignmentPattern for TSParameterProperty with initializer
+        let pattern = deserializeBindingPattern(pos + 32),
+          initializer = deserializeOptionBoxExpression(pos + 56),
+          assignStart,
+          assignEnd,
+          assignParam = (parent = {
+            __proto__: NodeProto,
+            type: 'AssignmentPattern',
+            decorators: [],
+            left: null,
+            right: null,
+            optional: false,
+            typeAnnotation: null,
+            start: (assignStart = pattern.start),
+            end: (assignEnd = initializer.end),
+            range: [assignStart, assignEnd],
+            parent: param,
+          });
+        assignParam.left = pattern;
+        pattern.parent = assignParam;
+        pattern.decorators = [];
+        pattern.optional = false;
+        parent = pattern;
+        let patternTypeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 48);
+        pattern.typeAnnotation = patternTypeAnnotation;
+        // Extend pattern span to include type annotation
+        if (patternTypeAnnotation !== null) {
+          pattern.end = patternTypeAnnotation.end;
+          pattern.range[1] = patternTypeAnnotation.end;
+        }
+        parent = assignParam;
+        assignParam.right = initializer;
+        initializer !== null && (initializer.parent = assignParam);
+        param.parameter = assignParam;
+      } else {
+        param.parameter = deserializeBindingPattern(pos + 32);
+        param.parameter.decorators = [];
+        let paramOptional = deserializeBool(pos + 64);
+        param.parameter.optional = paramOptional;
+        parent = param.parameter;
+        let paramTypeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 48);
+        param.parameter.typeAnnotation = paramTypeAnnotation;
+        // Extend parameter span to include type annotation or optional marker
+        if (paramTypeAnnotation !== null) {
+          param.parameter.end = paramTypeAnnotation.end;
+          param.parameter.range[1] = paramTypeAnnotation.end;
+        } else if (paramOptional) {
+          // Optional marker '?' is included in FormalParameter span
+          let paramEnd = deserializeU32(pos + 4);
+          param.parameter.end = paramEnd;
+          param.parameter.range[1] = paramEnd;
+        }
+        parent = param;
+      }
     }
-    parent = previousParent;
   }
+  parent = previousParent;
   return param;
 }
 
@@ -6308,14 +6425,23 @@ function deserializeVecVariableDeclarator(pos) {
   let arr = [],
     pos32 = pos >> 2;
   pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 64;
+  let endPos = pos + uint32[pos32 + 2] * 56;
   for (; pos !== endPos; ) {
     arr.push(deserializeVariableDeclarator(pos));
-    pos += 64;
+    pos += 56;
   }
   return arr;
 }
 
+function deserializeBoxTSTypeAnnotation(pos) {
+  return deserializeTSTypeAnnotation(uint32[pos >> 2]);
+}
+
+function deserializeOptionBoxTSTypeAnnotation(pos) {
+  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
+  return deserializeBoxTSTypeAnnotation(pos);
+}
+
 function deserializeOptionStatement(pos) {
   if (uint8[pos] === 70) return null;
   return deserializeStatement(pos);
@@ -6358,19 +6484,10 @@ function deserializeOptionBoxBlockStatement(pos) {
 }
 
 function deserializeOptionCatchParameter(pos) {
-  if (uint8[pos + 32] === 2) return null;
+  if (uint8[pos + 8] === 4) return null;
   return deserializeCatchParameter(pos);
 }
 
-function deserializeBoxTSTypeAnnotation(pos) {
-  return deserializeTSTypeAnnotation(uint32[pos >> 2]);
-}
-
-function deserializeOptionBoxTSTypeAnnotation(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
-  return deserializeBoxTSTypeAnnotation(pos);
-}
-
 function deserializeBoxBindingIdentifier(pos) {
   return deserializeBindingIdentifier(uint32[pos >> 2]);
 }
@@ -6391,10 +6508,10 @@ function deserializeVecBindingProperty(pos) {
   let arr = [],
     pos32 = pos >> 2;
   pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 64;
+  let endPos = pos + uint32[pos32 + 2] * 48;
   for (; pos !== endPos; ) {
     arr.push(deserializeBindingProperty(pos));
-    pos += 64;
+    pos += 48;
   }
   return arr;
 }
@@ -6409,18 +6526,18 @@ function deserializeOptionBoxBindingRestElement(pos) {
 }
 
 function deserializeOptionBindingPattern(pos) {
-  if (uint8[pos + 24] === 2) return null;
+  if (uint8[pos] === 4) return null;
   return deserializeBindingPattern(pos);
 }
 
 function deserializeVecOptionBindingPattern(pos) {
   let arr = [],
     pos32 = pos >> 2;
   pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 32;
+  let endPos = pos + uint32[pos32 + 2] * 16;
   for (; pos !== endPos; ) {
     arr.push(deserializeOptionBindingPattern(pos));
-    pos += 32;
+    pos += 16;
   }
   return arr;
 }
@@ -6485,6 +6602,15 @@ function deserializeVecDecorator(pos) {
   return arr;
 }
 
+function deserializeBoxExpression(pos) {
+  return deserializeExpression(uint32[pos >> 2]);
+}
+
+function deserializeOptionBoxExpression(pos) {
+  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
+  return deserializeBoxExpression(pos);
+}
+
 function deserializeOptionTSAccessibility(pos) {
   if (uint8[pos] === 3) return null;
   return deserializeTSAccessibility(pos);