@react-native/codegen 0.74.0 → 0.75.0-nightly-20240221-a1171f79f

package/lib/parsers/flow/parseFlowAndThrowErrors.js

@@ -0,0 +1,105 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly &&
+      (symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      })),
+      keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2
+      ? ownKeys(Object(source), !0).forEach(function (key) {
+          _defineProperty(target, key, source[key]);
+        })
+      : Object.getOwnPropertyDescriptors
+      ? Object.defineProperties(
+          target,
+          Object.getOwnPropertyDescriptors(source),
+        )
+      : ownKeys(Object(source)).forEach(function (key) {
+          Object.defineProperty(
+            target,
+            key,
+            Object.getOwnPropertyDescriptor(source, key),
+          );
+        });
+  }
+  return target;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true,
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, 'string');
+  return typeof key === 'symbol' ? key : String(key);
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== 'object' || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || 'default');
+    if (typeof res !== 'object') return res;
+    throw new TypeError('@@toPrimitive must return a primitive value.');
+  }
+  return (hint === 'string' ? String : Number)(input);
+}
+const hermesParser = require('hermes-parser');
+function parseFlowAndThrowErrors(code, options = {}) {
+  let ast;
+  try {
+    ast = hermesParser.parse(
+      code,
+      _objectSpread(
+        {
+          // Produce an ESTree-compliant AST
+          babel: false,
+          // Parse Flow without a pragma
+          flow: 'all',
+        },
+        options.filename != null
+          ? {
+              sourceFilename: options.filename,
+            }
+          : {},
+      ),
+    );
+  } catch (e) {
+    if (options.filename != null) {
+      e.message = `Syntax error in ${options.filename}: ${e.message}`;
+    }
+    throw e;
+  }
+  return ast;
+}
+module.exports = {
+  parseFlowAndThrowErrors,
+};

package/lib/parsers/flow/parseFlowAndThrowErrors.js.flow

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {Program as ESTreeProgram} from 'hermes-estree';
+
+const hermesParser = require('hermes-parser');
+
+function parseFlowAndThrowErrors(
+  code: string,
+  options: $ReadOnly<{filename?: ?string}> = {},
+): ESTreeProgram {
+  let ast;
+  try {
+    ast = hermesParser.parse(code, {
+      // Produce an ESTree-compliant AST
+      babel: false,
+      // Parse Flow without a pragma
+      flow: 'all',
+      ...(options.filename != null ? {sourceFilename: options.filename} : {}),
+    });
+  } catch (e) {
+    if (options.filename != null) {
+      e.message = `Syntax error in ${options.filename}: ${e.message}`;
+    }
+    throw e;
+  }
+  return ast;
+}
+
+module.exports = {
+  parseFlowAndThrowErrors,
+};

package/lib/parsers/flow/parser.js

@@ -38,31 +38,30 @@ function _toPrimitive(input, hint) {
   }
   return (hint === 'string' ? String : Number)(input);
 }
-const invariant = require('invariant');
-const _require = require('./components/componentsUtils'),
-  getSchemaInfo = _require.getSchemaInfo,
-  getTypeAnnotation = _require.getTypeAnnotation,
-  flattenProperties = _require.flattenProperties;
-const _require2 = require('./modules'),
-  flowTranslateTypeAnnotation = _require2.flowTranslateTypeAnnotation;
-
-// $FlowFixMe[untyped-import] there's no flowtype flow-parser
-const flowParser = require('flow-parser');
-const _require3 = require('../parsers-commons'),
-  buildSchema = _require3.buildSchema,
-  buildPropSchema = _require3.buildPropSchema,
-  buildModuleSchema = _require3.buildModuleSchema,
-  handleGenericTypeAnnotation = _require3.handleGenericTypeAnnotation;
-const _require4 = require('../parsers-primitives'),
-  Visitor = _require4.Visitor;
+const _require = require('../errors'),
+  UnsupportedObjectPropertyTypeAnnotationParserError =
+    _require.UnsupportedObjectPropertyTypeAnnotationParserError;
+const _require2 = require('../parsers-commons'),
+  buildModuleSchema = _require2.buildModuleSchema,
+  buildPropSchema = _require2.buildPropSchema,
+  buildSchema = _require2.buildSchema,
+  handleGenericTypeAnnotation = _require2.handleGenericTypeAnnotation;
+const _require3 = require('../parsers-primitives'),
+  Visitor = _require3.Visitor;
+const _require4 = require('../schema.js'),
+  wrapComponentSchema = _require4.wrapComponentSchema;
 const _require5 = require('./components'),
   buildComponentSchema = _require5.buildComponentSchema;
-const _require6 = require('../schema.js'),
-  wrapComponentSchema = _require6.wrapComponentSchema;
+const _require6 = require('./components/componentsUtils'),
+  flattenProperties = _require6.flattenProperties,
+  getSchemaInfo = _require6.getSchemaInfo,
+  getTypeAnnotation = _require6.getTypeAnnotation;
+const _require7 = require('./modules'),
+  flowTranslateTypeAnnotation = _require7.flowTranslateTypeAnnotation;
+const _require8 = require('./parseFlowAndThrowErrors'),
+  parseFlowAndThrowErrors = _require8.parseFlowAndThrowErrors;
 const fs = require('fs');
-const _require7 = require('../errors'),
-  UnsupportedObjectPropertyTypeAnnotationParserError =
-    _require7.UnsupportedObjectPropertyTypeAnnotationParserError;
+const invariant = require('invariant');
 class FlowParser {
   constructor() {
     _defineProperty(
@@ -146,9 +145,9 @@ class FlowParser {
     const contents = fs.readFileSync(filename, 'utf8');
     return this.parseString(contents, 'path/NativeSampleTurboModule.js');
   }
-  getAst(contents) {
-    return flowParser.parse(contents, {
-      enums: true,
+  getAst(contents, filename) {
+    return parseFlowAndThrowErrors(contents, {
+      filename,
     });
   }
   getFunctionTypeAnnotationParameters(functionTypeAnnotation) {

package/lib/parsers/flow/parser.js.flow

@@ -11,17 +11,17 @@
 'use strict';
 
 import type {
-  UnionTypeAnnotationMemberType,
-  SchemaType,
+  ExtendsPropsShape,
   NamedShape,
-  Nullable,
-  NativeModuleParamTypeAnnotation,
-  NativeModuleEnumMemberType,
-  NativeModuleEnumMembers,
   NativeModuleAliasMap,
   NativeModuleEnumMap,
+  NativeModuleEnumMembers,
+  NativeModuleEnumMemberType,
+  NativeModuleParamTypeAnnotation,
+  Nullable,
   PropTypeAnnotation,
-  ExtendsPropsShape,
+  SchemaType,
+  UnionTypeAnnotationMemberType,
 } from '../../CodegenSchema';
 import type {ParserType} from '../errors';
 import type {
@@ -32,44 +32,37 @@ import type {
 } from '../parser';
 import type {
   ParserErrorCapturer,
-  TypeDeclarationMap,
   PropAST,
+  TypeDeclarationMap,
   TypeResolutionStatus,
 } from '../utils';
 
-type ExtendsForProp = null | {
-  type: 'ReactNativeBuiltInType',
-  knownTypeName: 'ReactNativeCoreViewProps',
-};
-
-const invariant = require('invariant');
-
 const {
-  getSchemaInfo,
-  getTypeAnnotation,
-  flattenProperties,
-} = require('./components/componentsUtils');
-
-const {flowTranslateTypeAnnotation} = require('./modules');
-
-// $FlowFixMe[untyped-import] there's no flowtype flow-parser
-const flowParser = require('flow-parser');
-
+  UnsupportedObjectPropertyTypeAnnotationParserError,
+} = require('../errors');
 const {
-  buildSchema,
-  buildPropSchema,
   buildModuleSchema,
+  buildPropSchema,
+  buildSchema,
   handleGenericTypeAnnotation,
 } = require('../parsers-commons');
 const {Visitor} = require('../parsers-primitives');
-const {buildComponentSchema} = require('./components');
 const {wrapComponentSchema} = require('../schema.js');
-
+const {buildComponentSchema} = require('./components');
+const {
+  flattenProperties,
+  getSchemaInfo,
+  getTypeAnnotation,
+} = require('./components/componentsUtils');
+const {flowTranslateTypeAnnotation} = require('./modules');
+const {parseFlowAndThrowErrors} = require('./parseFlowAndThrowErrors');
 const fs = require('fs');
+const invariant = require('invariant');
 
-const {
-  UnsupportedObjectPropertyTypeAnnotationParserError,
-} = require('../errors');
+type ExtendsForProp = null | {
+  type: 'ReactNativeBuiltInType',
+  knownTypeName: 'ReactNativeCoreViewProps',
+};
 
 class FlowParser implements Parser {
   typeParameterInstantiation: string = 'TypeParameterInstantiation';
@@ -149,10 +142,8 @@ class FlowParser implements Parser {
     return this.parseString(contents, 'path/NativeSampleTurboModule.js');
   }
 
-  getAst(contents: string): $FlowFixMe {
-    return flowParser.parse(contents, {
-      enums: true,
-    });
+  getAst(contents: string, filename?: ?string): $FlowFixMe {
+    return parseFlowAndThrowErrors(contents, {filename});
   }
 
   getFunctionTypeAnnotationParameters(

package/lib/parsers/flow/utils.js.flow

@@ -10,7 +10,7 @@
 
 'use strict';
 
-import type {TypeDeclarationMap, ASTNode} from '../utils';
+import type {ASTNode, TypeDeclarationMap} from '../utils';
 
 function getValueFromTypes(value: ASTNode, types: TypeDeclarationMap): ASTNode {
   if (value.type === 'GenericTypeAnnotation' && types[value.id.name]) {

package/lib/parsers/parser.js.flow

@@ -11,24 +11,24 @@
 'use strict';
 
 import type {
-  UnionTypeAnnotationMemberType,
-  SchemaType,
+  ExtendsPropsShape,
   NamedShape,
-  Nullable,
-  NativeModuleParamTypeAnnotation,
-  NativeModuleEnumMemberType,
-  NativeModuleEnumMembers,
   NativeModuleAliasMap,
   NativeModuleEnumMap,
+  NativeModuleEnumMembers,
+  NativeModuleEnumMemberType,
+  NativeModuleParamTypeAnnotation,
+  Nullable,
   PropTypeAnnotation,
-  ExtendsPropsShape,
+  SchemaType,
+  UnionTypeAnnotationMemberType,
 } from '../CodegenSchema';
 import type {ParserType} from './errors';
 import type {
+  ASTNode,
   ParserErrorCapturer,
-  TypeDeclarationMap,
   PropAST,
-  ASTNode,
+  TypeDeclarationMap,
   TypeResolutionStatus,
 } from './utils';
 
@@ -169,9 +169,11 @@ export interface Parser {
   /**
    * Given the content of a file, it returns an AST.
    * @parameter contents: the content of the file.
+   * @parameter filename: the name of the file, if available.
+   * @throws if there is a syntax error.
    * @returns: the AST of the file.
    */
-  getAst(contents: string): $FlowFixMe;
+  getAst(contents: string, filename?: ?string): $FlowFixMe;
 
   /**
    * Given a FunctionTypeAnnotation, it returns an array of its parameters.

package/lib/parsers/parserMock.js

@@ -39,16 +39,15 @@ function _toPrimitive(input, hint) {
   return (hint === 'string' ? String : Number)(input);
 }
 import invariant from 'invariant';
-const _require = require('./typescript/components/componentsUtils'),
-  flattenProperties = _require.flattenProperties;
-const _require2 = require('./parsers-commons'),
-  buildPropSchema = _require2.buildPropSchema;
-
-// $FlowFixMe[untyped-import] there's no flowtype flow-parser
-const flowParser = require('flow-parser');
-const _require3 = require('./errors'),
+const _require = require('./errors'),
   UnsupportedObjectPropertyTypeAnnotationParserError =
-    _require3.UnsupportedObjectPropertyTypeAnnotationParserError;
+    _require.UnsupportedObjectPropertyTypeAnnotationParserError;
+const _require2 = require('./flow/parseFlowAndThrowErrors'),
+  parseFlowAndThrowErrors = _require2.parseFlowAndThrowErrors;
+const _require3 = require('./parsers-commons'),
+  buildPropSchema = _require3.buildPropSchema;
+const _require4 = require('./typescript/components/componentsUtils'),
+  flattenProperties = _require4.flattenProperties;
 const schemaMock = {
   modules: {
     StringPropNativeComponentView: {
@@ -126,9 +125,9 @@ export class MockedParser {
   parseModuleFixture(filename) {
     return schemaMock;
   }
-  getAst(contents) {
-    return flowParser.parse(contents, {
-      enums: true,
+  getAst(contents, filename) {
+    return parseFlowAndThrowErrors(contents, {
+      filename,
     });
   }
   getFunctionTypeAnnotationParameters(functionTypeAnnotation) {

package/lib/parsers/parserMock.js.flow

@@ -11,46 +11,45 @@
 'use strict';
 
 import type {
-  GetSchemaInfoFN,
-  GetTypeAnnotationFN,
-  Parser,
-  ResolveTypeAnnotationFN,
-} from './parser';
-import type {ParserType} from './errors';
-type ExtendsForProp = null | {
-  type: 'ReactNativeBuiltInType',
-  knownTypeName: 'ReactNativeCoreViewProps',
-};
-import type {
-  UnionTypeAnnotationMemberType,
-  SchemaType,
+  ExtendsPropsShape,
   NamedShape,
-  Nullable,
-  NativeModuleParamTypeAnnotation,
-  NativeModuleEnumMemberType,
-  NativeModuleEnumMembers,
   NativeModuleAliasMap,
   NativeModuleEnumMap,
+  NativeModuleEnumMembers,
+  NativeModuleEnumMemberType,
+  NativeModuleParamTypeAnnotation,
+  Nullable,
   PropTypeAnnotation,
-  ExtendsPropsShape,
+  SchemaType,
+  UnionTypeAnnotationMemberType,
 } from '../CodegenSchema';
+import type {ParserType} from './errors';
+import type {
+  GetSchemaInfoFN,
+  GetTypeAnnotationFN,
+  Parser,
+  ResolveTypeAnnotationFN,
+} from './parser';
 import type {
   ParserErrorCapturer,
   PropAST,
   TypeDeclarationMap,
   TypeResolutionStatus,
 } from './utils';
-import invariant from 'invariant';
 
-const {flattenProperties} = require('./typescript/components/componentsUtils');
-
-const {buildPropSchema} = require('./parsers-commons');
+import invariant from 'invariant';
 
-// $FlowFixMe[untyped-import] there's no flowtype flow-parser
-const flowParser = require('flow-parser');
 const {
   UnsupportedObjectPropertyTypeAnnotationParserError,
 } = require('./errors');
+const {parseFlowAndThrowErrors} = require('./flow/parseFlowAndThrowErrors');
+const {buildPropSchema} = require('./parsers-commons');
+const {flattenProperties} = require('./typescript/components/componentsUtils');
+
+type ExtendsForProp = null | {
+  type: 'ReactNativeBuiltInType',
+  knownTypeName: 'ReactNativeCoreViewProps',
+};
 
 const schemaMock = {
   modules: {
@@ -122,10 +121,8 @@ export class MockedParser implements Parser {
     return schemaMock;
   }
 
-  getAst(contents: string): $FlowFixMe {
-    return flowParser.parse(contents, {
-      enums: true,
-    });
+  getAst(contents: string, filename?: ?string): $FlowFixMe {
+    return parseFlowAndThrowErrors(contents, {filename});
   }
 
   getFunctionTypeAnnotationParameters(

package/lib/parsers/parsers-commons.js

@@ -140,47 +140,49 @@ function _iterableToArrayLimit(arr, i) {
 function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
 }
-const _require = require('./utils'),
-  getConfigType = _require.getConfigType,
-  extractNativeModuleName = _require.extractNativeModuleName,
-  createParserErrorCapturer = _require.createParserErrorCapturer,
-  visit = _require.visit,
-  isModuleRegistryCall = _require.isModuleRegistryCall,
-  verifyPlatforms = _require.verifyPlatforms;
-const _require2 = require('./error-utils'),
+const _require = require('./error-utils'),
+  throwIfConfigNotfound = _require.throwIfConfigNotfound,
+  throwIfIncorrectModuleRegistryCallArgument =
+    _require.throwIfIncorrectModuleRegistryCallArgument,
+  throwIfIncorrectModuleRegistryCallTypeParameterParserError =
+    _require.throwIfIncorrectModuleRegistryCallTypeParameterParserError,
+  throwIfModuleInterfaceIsMisnamed = _require.throwIfModuleInterfaceIsMisnamed,
+  throwIfModuleInterfaceNotFound = _require.throwIfModuleInterfaceNotFound,
+  throwIfModuleTypeIsUnsupported = _require.throwIfModuleTypeIsUnsupported,
+  throwIfMoreThanOneCodegenNativecommands =
+    _require.throwIfMoreThanOneCodegenNativecommands,
+  throwIfMoreThanOneConfig = _require.throwIfMoreThanOneConfig,
+  throwIfMoreThanOneModuleInterfaceParserError =
+    _require.throwIfMoreThanOneModuleInterfaceParserError,
+  throwIfMoreThanOneModuleRegistryCalls =
+    _require.throwIfMoreThanOneModuleRegistryCalls,
   throwIfPropertyValueTypeIsUnsupported =
-    _require2.throwIfPropertyValueTypeIsUnsupported,
+    _require.throwIfPropertyValueTypeIsUnsupported,
+  throwIfTypeAliasIsNotInterface = _require.throwIfTypeAliasIsNotInterface,
   throwIfUnsupportedFunctionParamTypeAnnotationParserError =
-    _require2.throwIfUnsupportedFunctionParamTypeAnnotationParserError,
+    _require.throwIfUnsupportedFunctionParamTypeAnnotationParserError,
   throwIfUnsupportedFunctionReturnTypeAnnotationParserError =
-    _require2.throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
-  throwIfModuleTypeIsUnsupported = _require2.throwIfModuleTypeIsUnsupported,
+    _require.throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
+  throwIfUntypedModule = _require.throwIfUntypedModule,
   throwIfUnusedModuleInterfaceParserError =
-    _require2.throwIfUnusedModuleInterfaceParserError,
-  throwIfMoreThanOneModuleRegistryCalls =
-    _require2.throwIfMoreThanOneModuleRegistryCalls,
+    _require.throwIfUnusedModuleInterfaceParserError,
   throwIfWrongNumberOfCallExpressionArgs =
-    _require2.throwIfWrongNumberOfCallExpressionArgs,
-  throwIfUntypedModule = _require2.throwIfUntypedModule,
-  throwIfIncorrectModuleRegistryCallTypeParameterParserError =
-    _require2.throwIfIncorrectModuleRegistryCallTypeParameterParserError,
-  throwIfIncorrectModuleRegistryCallArgument =
-    _require2.throwIfIncorrectModuleRegistryCallArgument,
-  throwIfModuleInterfaceNotFound = _require2.throwIfModuleInterfaceNotFound,
-  throwIfMoreThanOneModuleInterfaceParserError =
-    _require2.throwIfMoreThanOneModuleInterfaceParserError,
-  throwIfModuleInterfaceIsMisnamed = _require2.throwIfModuleInterfaceIsMisnamed,
-  throwIfMoreThanOneCodegenNativecommands =
-    _require2.throwIfMoreThanOneCodegenNativecommands,
-  throwIfConfigNotfound = _require2.throwIfConfigNotfound,
-  throwIfMoreThanOneConfig = _require2.throwIfMoreThanOneConfig,
-  throwIfTypeAliasIsNotInterface = _require2.throwIfTypeAliasIsNotInterface;
-const _require3 = require('./errors'),
+    _require.throwIfWrongNumberOfCallExpressionArgs;
+const _require2 = require('./errors'),
   MissingTypeParameterGenericParserError =
-    _require3.MissingTypeParameterGenericParserError,
+    _require2.MissingTypeParameterGenericParserError,
   MoreThanOneTypeParameterGenericParserError =
-    _require3.MoreThanOneTypeParameterGenericParserError,
-  UnnamedFunctionParamParserError = _require3.UnnamedFunctionParamParserError;
+    _require2.MoreThanOneTypeParameterGenericParserError,
+  UnnamedFunctionParamParserError = _require2.UnnamedFunctionParamParserError,
+  UnsupportedObjectDirectRecursivePropertyParserError =
+    _require2.UnsupportedObjectDirectRecursivePropertyParserError;
+const _require3 = require('./utils'),
+  createParserErrorCapturer = _require3.createParserErrorCapturer,
+  extractNativeModuleName = _require3.extractNativeModuleName,
+  getConfigType = _require3.getConfigType,
+  isModuleRegistryCall = _require3.isModuleRegistryCall,
+  verifyPlatforms = _require3.verifyPlatforms,
+  visit = _require3.visit;
 const invariant = require('invariant');
 function wrapModuleSchema(nativeModuleSchema, hasteModuleName) {
   return {
@@ -247,6 +249,7 @@ function isObjectProperty(property, language) {
   }
 }
 function parseObjectProperty(
+  parentObject,
   property,
   hasteModuleName,
   types,
@@ -266,6 +269,51 @@ function parseObjectProperty(
     language === 'TypeScript'
       ? property.typeAnnotation.typeAnnotation
       : property.value;
+
+  // Handle recursive types
+  if (parentObject) {
+    var _languageTypeAnnotati, _languageTypeAnnotati2;
+    const propertyType = parser.getResolveTypeAnnotationFN()(
+      languageTypeAnnotation,
+      types,
+      parser,
+    );
+    if (
+      propertyType.typeResolutionStatus.successful === true &&
+      propertyType.typeResolutionStatus.type === 'alias' &&
+      (language === 'TypeScript'
+        ? parentObject.typeName &&
+          parentObject.typeName.name ===
+            ((_languageTypeAnnotati = languageTypeAnnotation.typeName) ===
+              null || _languageTypeAnnotati === void 0
+              ? void 0
+              : _languageTypeAnnotati.name)
+        : parentObject.id &&
+          parentObject.id.name ===
+            ((_languageTypeAnnotati2 = languageTypeAnnotation.id) === null ||
+            _languageTypeAnnotati2 === void 0
+              ? void 0
+              : _languageTypeAnnotati2.name))
+    ) {
+      if (!optional) {
+        throw new UnsupportedObjectDirectRecursivePropertyParserError(
+          name,
+          languageTypeAnnotation,
+          hasteModuleName,
+        );
+      }
+      return {
+        name,
+        optional,
+        typeAnnotation: {
+          type: 'TypeAliasTypeAnnotation',
+          name: propertyType.typeResolutionStatus.name,
+        },
+      };
+    }
+  }
+
+  // Handle non-recursive types
   const _unwrapNullable = unwrapNullable(
       translateTypeAnnotation(
         hasteModuleName,
@@ -282,7 +330,7 @@ function parseObjectProperty(
     propertyTypeAnnotation = _unwrapNullable2[0],
     isPropertyNullable = _unwrapNullable2[1];
   if (
-    propertyTypeAnnotation.type === 'FunctionTypeAnnotation' ||
+    (propertyTypeAnnotation.type === 'FunctionTypeAnnotation' && !cxxOnly) ||
     propertyTypeAnnotation.type === 'PromiseTypeAnnotation' ||
     propertyTypeAnnotation.type === 'VoidTypeAnnotation'
   ) {
@@ -521,7 +569,7 @@ function buildSchema(
       modules: {},
     };
   }
-  const ast = parser.getAst(contents);
+  const ast = parser.getAst(contents, filename);
   const configType = getConfigType(ast, Visitor);
   return buildSchemaFromConfigType(
     configType,
@@ -714,6 +762,7 @@ function findNativeComponentType(statement, foundConfigs, parser) {
   // expression so we need to go one level deeper
   if (
     declaration.type === 'TSAsExpression' ||
+    declaration.type === 'AsExpression' ||
     declaration.type === 'TypeCastExpression'
   ) {
     declaration = declaration.expression;