chore: clean up

Author: JairusSW

src/module.ts

@@ -3899,17 +3899,19 @@ function prepareType(builder: binaryen.TypeBuilderRef, seen: Map<Type,HeapTypeRe
         if (DEBUG_TYPEBUILDER) {
           console.log(`  field ${fieldType.toString()}`);
         }
-        fieldTypes.push(
-          fieldType.is(TypeFlags.Nullable)
-            ? binaryen._TypeBuilderGetTempRefType(
-                builder,
-                binaryen._BinaryenTypeGetHeapType(
-                  prepareType(builder, seen, fieldType.nonNullableType)
-                ),
-                true
-              )
-            : prepareType(builder, seen, fieldType)
-        );
+        if (fieldType.is(TypeFlags.Nullable)) {
+          fieldTypes.push(
+            binaryen._TypeBuilderGetTempRefType(
+              builder,
+              binaryen._BinaryenTypeGetHeapType(
+                prepareType(builder, seen, fieldType.nonNullableType)
+              ),
+              true
+            )
+          );
+        } else {
+          fieldTypes.push(prepareType(builder, seen, fieldType));
+        }
         packedTypes.push(determinePackedType(fieldType));
         fieldMutables.push(1);
       }

src/parser.ts

@@ -610,13 +610,7 @@ export class Parser extends DiagnosticEmitter {
           return null;
         }
       }
-      type = Node.createTupleType(
-        elements,
-        hasElementNames ? elementNames : null,
-        false,
-        tn.range(startPos, tn.pos),
-        false
-      );
+      type = Node.createTupleType(elements, hasElementNames ? elementNames : null, false, tn.range(startPos, tn.pos), false);
 
     // 'void'
     } else if (token == Token.Void) {

src/resolver.ts

@@ -447,34 +447,14 @@ export class Resolver extends DiagnosticEmitter {
     } else {
       if (returnTypeNode.kind == NodeKind.TupleType && (<TupleTypeNode>returnTypeNode).isReadonly) {
         returnType = Type.void;
-        returnTypes = this.resolveMultiValueReturnTypes(
-          <TupleTypeNode>returnTypeNode,
-          flow,
-          ctxElement,
-          ctxTypes,
-          reportMode
-        );
+        returnTypes = this.resolveMultiValueReturnTypes(<TupleTypeNode>returnTypeNode, flow, ctxElement, ctxTypes, reportMode);
         if (!returnTypes) return null;
       } else {
-        returnType = this.resolveType(
-          returnTypeNode,
-          flow,
-          ctxElement,
-          ctxTypes,
-          reportMode
-        );
+        returnType = this.resolveType(returnTypeNode, flow, ctxElement, ctxTypes, reportMode);
       }
       if (!returnType) return null;
     }
-    let signature = Signature.create(
-      this.program,
-      parameterTypes,
-      returnType,
-      thisType,
-      requiredParameters,
-      hasRest,
-      returnTypes
-    );
+    let signature = Signature.create(this.program, parameterTypes, returnType, thisType, requiredParameters, hasRest, returnTypes);
     return node.isNullable ? signature.type.asNullable() : signature.type;
   }
 
@@ -2998,36 +2978,16 @@ export class Resolver extends DiagnosticEmitter {
       }
       if (typeNode.kind == NodeKind.TupleType && (<TupleTypeNode>typeNode).isReadonly) {
         returnType = Type.void;
-        returnTypes = this.resolveMultiValueReturnTypes(
-          <TupleTypeNode>typeNode,
-          null,
-          prototype.parent,
-          ctxTypes,
-          reportMode
-        );
+        returnTypes = this.resolveMultiValueReturnTypes(<TupleTypeNode>typeNode, null, prototype.parent, ctxTypes, reportMode);
         if (!returnTypes) return null;
       } else {
-        let type = this.resolveType(
-          typeNode,
-          null,
-          prototype.parent, // relative to function
-          ctxTypes,
-          reportMode
-        );
+        let type = this.resolveType(typeNode, null, prototype.parent, ctxTypes, reportMode);
         if (!type) return null;
         returnType = type;
       }
     }
 
-    let signature = Signature.create(
-      this.program,
-      parameterTypes,
-      returnType,
-      thisType,
-      requiredParameters,
-      hasRest,
-      returnTypes
-    );
+    let signature = Signature.create(this.program, parameterTypes, returnType, thisType, requiredParameters, hasRest, returnTypes);
 
     let nameInclTypeParameters = prototype.name;
     if (instanceKey.length) nameInclTypeParameters += `<${instanceKey}>`;

src/types.ts

@@ -962,17 +962,7 @@ export class Signature {
     let nextId = program.nextSignatureId;
 
     // construct the signature and calculate it's unique key
-    let signature = new Signature(
-      program,
-      parameterTypes,
-      returnType,
-      thisType,
-      requiredParameters,
-      hasRest,
-      nextId,
-      type,
-      returnTypes
-    );
+    let signature = new Signature(program, parameterTypes, returnType, thisType, requiredParameters, hasRest, nextId, type, returnTypes );
     let uniqueKey = signature.toString();
 
     // check if it exists, and return it