expo-type-information 0.0.8 → 0.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-type-information",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "keywords": [
     "react-native",
     "expo",
@@ -36,7 +36,7 @@
     "ts-jest": "^29.1.2",
     "expo-module-scripts": "56.0.3"
   },
-  "gitHead": "b293744c7b199c6cbe910188863e93a174c21250",
+  "gitHead": "b2e161a54f90a778ab7e5560c0c8f021bbfcaae2",
   "scripts": {
     "build": "expo-module build",
     "clean": "expo-module clean",

package/src/commands/commandUtils.ts

@@ -59,9 +59,8 @@ export function addCommonOptions(command: commander.Command): commander.Command
     )
     .option(
       '-t, --type-inference <typeInference>',
-      // TODO(@HubertBer) Fix the PREPROCESS_AND_INFERENCE option.
       'Level of type inference: `NO_INFERENCE`, `SIMPLE_INFERENCE`, or `PREPROCESS_AND_INFERENCE`. Note that the `PREPROCESS_AND_INFERENCE` option can occasionally fail on some modules. If you encountered errors, fall back to `SIMPLE_INFERENCE` or `NO_INFERENCE`.',
-      'SIMPLE_INFERENCE'
+      'PREPROCESS_AND_INFERENCE'
     )
     .option(
       '-s, --skip-unicode-character-mapping',

package/src/swift/sourcekittenTypeInformation.ts

@@ -560,7 +560,8 @@ async function parseModuleClassStructure(
 async function parseModuleFunctionSubstructure(
   substructure: Structure,
   file: FileType,
-  options: SwiftFileTypeInformationOptions
+  options: SwiftFileTypeInformationOptions,
+  isStatic: boolean
 ): Promise<FunctionDeclaration> {
   const definitionParams = substructure['key.substructure'];
   const nameSubstrucutre = definitionParams[0];
@@ -582,6 +583,7 @@ async function parseModuleFunctionSubstructure(
     parameters: [], // TODO(@HubertBer): Module function is not generic. I think so. Check it
     arguments: types?.parameters?.map(mapSourcekittenParameterToType) ?? [],
     definitionOffset: substructure['key.offset'],
+    isStatic,
   };
 }
 
@@ -694,10 +696,12 @@ function parseEnumStructure(enumStructure: Structure): EnumType {
     .flatMap((sub) => sub['key.substructure'])
     .map((sub) => sub['key.name'].split('(', 1)[0])
     .filter((enumcase) => enumcase !== undefined);
+  const stringBacked = !enumStructure['key.inheritedtypes']?.find((v) => v['key.name'] === 'Int');
 
   return {
     name: enumStructure['key.name'],
     cases: enumcases,
+    stringBacked,
   };
 }
 
@@ -780,7 +784,7 @@ async function parseModuleStructure(
       }
       case 'Function': {
         moduleClassDeclaration.functions.push(
-          await parseModuleFunctionSubstructure(structure, file, options)
+          await parseModuleFunctionSubstructure(structure, file, options, false)
         );
         break;
       }
@@ -805,7 +809,17 @@ async function parseModuleStructure(
       }
       case 'AsyncFunction':
         moduleClassDeclaration.asyncFunctions.push(
-          await parseModuleFunctionSubstructure(structure, file, options)
+          await parseModuleFunctionSubstructure(structure, file, options, false)
+        );
+        break;
+      case 'StaticAsyncFunction':
+        moduleClassDeclaration.asyncFunctions.push(
+          await parseModuleFunctionSubstructure(structure, file, options, true)
+        );
+        break;
+      case 'StaticFunction':
+        moduleClassDeclaration.functions.push(
+          await parseModuleFunctionSubstructure(structure, file, options, true)
         );
         break;
       case 'Constructor':
@@ -1087,30 +1101,51 @@ function removeComments(fileContent: string): string {
   });
 }
 
-function returnExpressionEnd(fileContent: string, returnIndex: number): number {
+// The assumption that after return there is an scope closing bracket '}' doesn't hold when switch cases and statements like `#if`, `#else` etc. are present
+// If they are we don't want to perform the substitution
+function stringSubstitutionIsValid(str: string): boolean {
+  const dangerousSubstrings = ['case ', '#if', '#else', '#endif'];
+  for (const substring of dangerousSubstrings) {
+    if (str.indexOf(substring) !== -1) {
+      return false;
+    }
+  }
+  return true;
+}
+
+type ExpressionEndResult = { expressionEnd: number; ok: boolean };
+function returnExpressionEnd(fileContent: string, returnIndex: number): ExpressionEndResult {
   let inString = false;
   let escaped = false;
-  let parenCount = 0;
   let braceCount = 0;
-  // TODO(@HubertBer): figure out what also changes the typical end of expression
-
+  // Doing a little cheat here to simplify the logic, we assume that the expression end is right before the scope closing `}`.
+  // While this isn't neccessarily true, in our case we only want to replace:
+  //
+  // return expression
+  //
+  // with:
+  //
+  // let return_expression = expression
+  // return return_expression
+  //
+  // such that return_expression variable has the return type of the expression and the file still parses correctly (This might not even be neccessary,
+  // sourcekitten seems to be quite flexible, it may parse part of malformed files just fine).
   let i = returnIndex;
   while (i < fileContent.length) {
     const char = fileContent[i];
     let escapedNow = false;
+    if (inString && char !== '"') {
+      i += 1;
+      continue;
+    }
     switch (char) {
-      case '(':
-        parenCount += 1;
-        break;
-      case ')':
-        parenCount -= 1;
-        break;
       case '{':
         braceCount += 1;
         break;
       case '}':
         if (braceCount === 0) {
-          return i;
+          const ok = stringSubstitutionIsValid(fileContent.substring(returnIndex, i));
+          return { expressionEnd: i, ok };
         }
         braceCount -= 1;
         break;
@@ -1119,21 +1154,13 @@ function returnExpressionEnd(fileContent: string, returnIndex: number): number {
           inString = !inString;
         }
         break;
-      case ';':
-        return i;
-      case '\n':
-      case '\r':
-        if (!inString && parenCount === 0 && braceCount === 0) {
-          return i;
-        }
-        break;
       case '\\':
         escapedNow = true;
     }
     escaped = escapedNow;
     i += 1;
   }
-  return i;
+  return { expressionEnd: i, ok: false };
 }
 
 type SourceKittenPreprocessingOptions = {
@@ -1141,37 +1168,57 @@ type SourceKittenPreprocessingOptions = {
   mapUnicodeCharacters?: boolean;
 };
 
+function getSpaceIndentationCount(fileContent: string, index: number): number {
+  const lastNewLineIndex = fileContent.lastIndexOf('\n', index - 1);
+  let spaceCount = 0;
+  let i = lastNewLineIndex === -1 ? 0 : 1 + lastNewLineIndex;
+  while (i < index && fileContent[i] === ' ') {
+    spaceCount += 1;
+    i += 1;
+  }
+  return spaceCount;
+}
+
 // Preprocessing to help sourcekitten functions
 // For now we create a new variable for each return statement,
 // we can find it's type easily with sourcekitten
-// TODO(@HubertBer): This has many problems which need fixing:
+// TODO(@HubertBer): This has many problems which may need fixing:
 // - return can be inside a string
-// - return Expression end parses incorrectly in case of some strings (check how it parses expo-video)
+// - the substitution may break the Swift code
 function preprocessReturnStatements(originalFileContent: string): string {
   const newFileContent: string[] = [];
   const fileContent = removeComments(originalFileContent);
-  const returnPositions: { start: number; end: number }[] = [];
+  const returnPositions: { start: number; end: number; spacesIndentation: number }[] = [];
   let startPos = 0;
   while (startPos < fileContent.length) {
     const returnIndex = fileContent.indexOf('return ', startPos);
     if (returnIndex < 0 || returnIndex >= fileContent.length) {
       break;
     }
+    const { expressionEnd, ok } = returnExpressionEnd(fileContent, returnIndex);
+    if (!ok) {
+      startPos += 1;
+      continue;
+    }
     returnPositions.push({
       start: returnIndex,
-      end: returnExpressionEnd(fileContent, returnIndex),
+      end: expressionEnd,
+      spacesIndentation: getSpaceIndentationCount(fileContent, returnIndex),
     });
-    startPos = returnIndex + 1;
+    // Going to expressionEnd instead of next index to avoid nested return statements, which in this simple method we cannot handle properly.
+    startPos = expressionEnd + 1;
   }
 
   let prevEnd = 0;
 
-  for (const { start, end } of returnPositions) {
+  for (const { start, end, spacesIndentation } of returnPositions) {
     newFileContent.push(fileContent.substring(prevEnd, start));
+    // Make sure the return statement has the same indentation as in original file, to make debugging easier
+    const spaces = ' '.repeat(spacesIndentation);
     newFileContent.push(
-      `\nlet returnValueDeclaration_${start}_${end} = ${fileContent.substring(start + 6, end)}\n`
+      `\n${spaces}let returnValueDeclaration_${start}_${end} = ${fileContent.substring(start + 6, end)}`
     );
-    newFileContent.push(`return returnValueDeclaration_${start}_${end}\n`);
+    newFileContent.push(`\n${spaces}return returnValueDeclaration_${start}_${end}\n`);
     prevEnd = end;
   }
   newFileContent.push(fileContent.substring(prevEnd, fileContent.length));

package/src/typeInformation.ts

@@ -54,6 +54,7 @@ export type EnumCase = string;
  */
 export type EnumType = {
   name: string;
+  stringBacked: boolean;
   cases: EnumCase[];
 };
 
@@ -171,6 +172,7 @@ export type FunctionDeclaration = {
   returnType: Type;
   arguments: Argument[];
   parameters: Type[];
+  isStatic: boolean;
 } & DefinitionOffset;
 
 /**

package/src/typescriptGeneration.ts

@@ -31,6 +31,7 @@ const exportModifier = () => ts.factory.createModifier(ts.SyntaxKind.ExportKeywo
 const declareModifier = () => ts.factory.createModifier(ts.SyntaxKind.DeclareKeyword);
 const asyncModifier = () => ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword);
 const readonlyModifier = () => ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword);
+const staticModifier = () => ts.factory.createModifier(ts.SyntaxKind.StaticKeyword);
 const constModifier = () => ts.factory.createModifier(ts.SyntaxKind.ConstKeyword);
 const defaultModifier = () => ts.factory.createModifier(ts.SyntaxKind.DefaultKeyword);
 
@@ -108,12 +109,14 @@ function constructModifiersArray(modifiers: {
   declare?: boolean;
   async?: boolean;
   readonly?: boolean;
+  isStatic?: boolean;
 }): ts.Modifier[] {
   const modifiersArray: ts.Modifier[] = [];
   if (modifiers.exported) modifiersArray.push(exportModifier());
   if (modifiers.declare) modifiersArray.push(declareModifier());
   if (modifiers.async) modifiersArray.push(asyncModifier());
   if (modifiers.readonly) modifiersArray.push(readonlyModifier());
+  if (modifiers.isStatic) modifiersArray.push(staticModifier());
   return modifiersArray;
 }
 
@@ -579,7 +582,11 @@ export function buildFunction({
   overrideArgumentDeclarations,
   omitReturnType,
 }: buildFunctionOptions): ts.FunctionDeclaration | ts.MethodDeclaration {
-  const functionModifiers = constructModifiersArray({ exported, async: async && !declaration });
+  const functionModifiers = constructModifiersArray({
+    exported,
+    async: async && !declaration,
+    isStatic: functionDeclaration.isStatic,
+  });
   const customReturn = !!returnStatement;
   const bareReturnTypeNode = mapTypeToTsTypeNode(functionDeclaration.returnType);
 
@@ -735,7 +742,10 @@ export function buildEnumTypeDeclaration(
     constructModifiersArray({ exported, declare: declared }),
     enumType.name,
     enumType.cases.map((enumcase) =>
-      ts.factory.createEnumMember(enumcase, ts.factory.createStringLiteral(enumcase))
+      ts.factory.createEnumMember(
+        enumcase,
+        enumType.stringBacked ? ts.factory.createStringLiteral(enumcase) : undefined
+      )
     )
   );
 }

package/tests/TestModule.swift

@@ -105,6 +105,12 @@ public class TestModule: Module {
       AsyncFunction("TestAsyncFunction") { (a: Int) async -> String in 
         "string"
       }
+
+      StaticAsyncFunction("TestStaticAsyncFunction") { (a: String) async -> Void in }
+
+      StaticFunction("TestStaticFunction") { () async -> String in 
+        "string"
+      }
     }
 
     Class(TestEmptyClass.self) {
@@ -176,8 +182,17 @@ class TestRecordClass: Record {
   var field2: String
 }
 
-enum TestEnum {
+enum TestEnum: String {
   case simpleCase
   case multipleCases1, multipleCases2
   case caseWithArgs1(Int, Double, String), caseWithArgs2(Double, String, Either<Int, String>)
 }
+
+enum IntBackedEnum1: Int {
+  case simpleCase
+  case multipleCases1, multipleCases2
+}
+
+enum IntBackedEnum2: Something, Int, SomethingElse {
+  case simpleCase
+}