feat: add more null types for types the runtime accept or returns as null

metadata-generator/src/Binary/binaryTypeEncodingSerializer.cpp

@@ -292,6 +292,12 @@ binary::BinaryTypeEncodingSerializer::visitNullable(
   return type.innerType->visit(*this);
 }
 
+unique_ptr<binary::TypeEncoding>
+binary::BinaryTypeEncodingSerializer::visitNonNullable(
+    const ::Meta::NonNullableType& type) {
+  return type.innerType->visit(*this);
+}
+
 unique_ptr<binary::TypeEncoding>
 binary::BinaryTypeEncodingSerializer::serializeRecordEncoding(
     const binary::BinaryTypeEncodingType encodingType,

metadata-generator/src/Binary/binaryTypeEncodingSerializer.h

@@ -118,5 +118,8 @@ class BinaryTypeEncodingSerializer
 
   virtual unique_ptr<TypeEncoding> visitNullable(
       const ::Meta::NullableType& type) override;
+
+  virtual unique_ptr<TypeEncoding> visitNonNullable(
+      const ::Meta::NonNullableType& type) override;
 };
 }  // namespace binary

metadata-generator/src/Meta/NameRetrieverVisitor.cpp

@@ -178,6 +178,11 @@ std::string NameRetrieverVisitor::visitNullable(
   return type.innerType->visit(*this);
 }
 
+std::string NameRetrieverVisitor::visitNonNullable(
+    const ::Meta::NonNullableType& type) {
+  return type.innerType->visit(*this);
+}
+
 std::string NameRetrieverVisitor::generateFixedArray(const Type* el_type,
                                                      size_t size) {
   std::stringstream ss(el_type->visit(*this));

metadata-generator/src/Meta/NameRetrieverVisitor.h

@@ -99,6 +99,8 @@ class NameRetrieverVisitor : public ::Meta::TypeVisitor<std::string> {
 
   virtual std::string visitNullable(const ::Meta::NullableType& type);
 
+  virtual std::string visitNonNullable(const ::Meta::NonNullableType& type);
+
  private:
   NameRetrieverVisitor(bool tsNames) : tsNames(tsNames) {}
 

metadata-generator/src/Meta/TypeEntities.h

@@ -50,7 +50,8 @@ enum TypeType {
   TypeEnum,
   TypeTypeArgument,
   TypeExtVector,
-  TypeNullable
+  TypeNullable,
+  TypeNonNullable
 };
 
 class Type {
@@ -150,6 +151,8 @@ class Type {
         return visitor.visitExtVector(as<ExtVectorType>());
       case TypeNullable:
         return visitor.visitNullable(as<NullableType>());
+      case TypeNonNullable:
+        return visitor.visitNonNullable(as<NonNullableType>());
     }
   }
 
@@ -324,4 +327,12 @@ class NullableType : public Type {
 
   Type* innerType;
 };
+
+class NonNullableType : public Type {
+ public:
+  NonNullableType(Type* innerType)
+      : Type(TypeType::TypeNonNullable), innerType(innerType) {}
+
+  Type* innerType;
+};
 }  // namespace Meta

metadata-generator/src/Meta/TypeFactory.cpp

@@ -508,6 +508,8 @@ shared_ptr<Type> TypeFactory::createFromAttributedType(
   if (auto nullability = type->getImmediateNullability()) {
     if (*nullability == clang::NullabilityKind::Nullable) {
       return make_shared<NullableType>(innerType.get());
+    } else if (*nullability == clang::NullabilityKind::NonNull) {
+      return make_shared<NonNullableType>(innerType.get());
     }
   }
   return innerType;

metadata-generator/src/Meta/TypeVisitor.h

@@ -19,6 +19,7 @@ class EnumType;
 class TypeArgumentType;
 class ExtVectorType;
 class NullableType;
+class NonNullableType;
 
 /*
  * \class TypeVisitor<T>
@@ -107,5 +108,7 @@ class TypeVisitor {
   virtual T_RESULT visitTypeArgument(const ::Meta::TypeArgumentType& type) = 0;
 
   virtual T_RESULT visitNullable(const ::Meta::NullableType& type) = 0;
+
+  virtual T_RESULT visitNonNullable(const ::Meta::NonNullableType& type) = 0;
 };
 }  // namespace Meta

metadata-generator/src/Meta/ValidateMetaTypeVisitor.cpp

@@ -171,3 +171,10 @@ bool ValidateMetaTypeVisitor::visitNullable(const NullableType& typeDetails) {
 
   return true;
 }
+
+bool ValidateMetaTypeVisitor::visitNonNullable(
+    const NonNullableType& typeDetails) {
+  typeDetails.innerType->visit(*this);
+
+  return true;
+}

metadata-generator/src/Meta/ValidateMetaTypeVisitor.h

@@ -93,6 +93,8 @@ class ValidateMetaTypeVisitor : public TypeVisitor<bool> {
 
   virtual bool visitNullable(const ::Meta::NullableType& type);
 
+  virtual bool visitNonNullable(const ::Meta::NonNullableType& type);
+
  private:
   MetaFactory& _metaFactory;
 };

metadata-generator/src/TypeScript/DefinitionWriter.cpp

@@ -949,7 +949,8 @@ bool DefinitionWriter::hasClosedGenerics(const Type& type) {
 }
 
 std::string DefinitionWriter::tsifyType(const Type& type,
-                                        const bool isFuncParam) {
+                                        const bool isFuncParam,
+                                        const bool suppressNull) {
   switch (type.getType()) {
     case TypeVoid:
       return "void";
@@ -1011,6 +1012,9 @@ std::string DefinitionWriter::tsifyType(const Type& type,
       if (isFuncParam) {
         result += " | ArrayBufferLike | ArrayBufferView";
       }
+      if (!suppressNull) {
+        result += " | null";
+      }
       return result;
     }
     case TypeBlock:
@@ -1130,8 +1134,16 @@ std::string DefinitionWriter::tsifyType(const Type& type,
       return type.as<TypeArgumentType>().name;
     case TypeNullable: {
       const NullableType& nullableType = type.as<NullableType>();
+      if (nullableType.innerType->is(TypePointer)) {
+        return tsifyType(*nullableType.innerType, isFuncParam);
+      }
       return tsifyType(*nullableType.innerType, isFuncParam) + " | null";
     }
+    case TypeNonNullable: {
+      const NonNullableType& nonNullType = type.as<NonNullableType>();
+      bool suppress = isFuncParam;
+      return tsifyType(*nonNullType.innerType, isFuncParam, suppress);
+    }
     case TypeVaList:
     case TypeInstancetype:
     default:

metadata-generator/src/TypeScript/DefinitionWriter.h

@@ -1,87 +1,107 @@
 #pragma once
 
-#include "DocSetManager.h"
-#include "Meta/MetaEntities.h"
 #include <Meta/TypeFactory.h>
+
 #include <sstream>
 #include <string>
 #include <unordered_set>
 
+#include "DocSetManager.h"
+#include "Meta/MetaEntities.h"
+
 namespace TypeScript {
 class DefinitionWriter : Meta::MetaVisitor {
-public:
-    DefinitionWriter(std::pair<clang::Module*, std::vector<Meta::Meta*> >& module, Meta::TypeFactory& typeFactory, std::string docSetPath)
-        : _module(module)
-        , _typeFactory(typeFactory)
-        , _docSet(docSetPath)
-    {
-    }
-
-    std::string write();
-
-    static bool applyManualChanges;
-
-    virtual void visit(Meta::InterfaceMeta* meta) override;
-
-    virtual void visit(Meta::ProtocolMeta* meta) override;
-
-    virtual void visit(Meta::CategoryMeta* meta) override;
-
-    virtual void visit(Meta::FunctionMeta* meta) override;
-
-    virtual void visit(Meta::StructMeta* meta) override;
-
-    virtual void visit(Meta::UnionMeta* meta) override;
-
-    virtual void visit(Meta::EnumMeta* meta) override;
-
-    virtual void visit(Meta::VarMeta* meta) override;
-
-    virtual void visit(Meta::MethodMeta* meta) override;
-
-    virtual void visit(Meta::PropertyMeta* meta) override;
-
-    virtual void visit(Meta::EnumConstantMeta* meta) override;
-
-private:
-    template <class Member>
-    using CompoundMemberMap = std::map<std::string, std::pair<Meta::BaseClassMeta*, Member*> >;
-
-    void writeMembers(const std::vector<Meta::RecordField>& fields, std::vector<TSComment> fieldsComments);
-    void writeProperty(Meta::PropertyMeta* meta, Meta::BaseClassMeta* owner, Meta::InterfaceMeta* target, CompoundMemberMap<Meta::PropertyMeta> compoundProperties);
-
-    static void getInheritedMembersRecursive(Meta::InterfaceMeta* interface,
-        CompoundMemberMap<Meta::MethodMeta>* staticMethods,
-        CompoundMemberMap<Meta::MethodMeta>* instanceMethods,
-        CompoundMemberMap<Meta::PropertyMeta>* staticProperties,
-        CompoundMemberMap<Meta::PropertyMeta>* instanceProperties);
-
-    static void getProtocolMembersRecursive(Meta::ProtocolMeta* protocol,
-        CompoundMemberMap<Meta::MethodMeta>* staticMethods,
-        CompoundMemberMap<Meta::MethodMeta>* instanceMethods,
-        CompoundMemberMap<Meta::PropertyMeta>* staticProperties,
-        CompoundMemberMap<Meta::PropertyMeta>* instanceProperties,
-        std::unordered_set<Meta::ProtocolMeta*>& visitedProtocols);
-
-    static std::string writeConstructor(const CompoundMemberMap<Meta::MethodMeta>::value_type& initializer,
-        const Meta::BaseClassMeta* owner);
-    static std::string writeMethod(Meta::MethodMeta* meta, Meta::BaseClassMeta* owner, bool canUseThisType = false);
-    static std::string writeMethod(CompoundMemberMap<Meta::MethodMeta>::value_type& method, Meta::BaseClassMeta* owner,
-        const std::unordered_set<Meta::ProtocolMeta*>& protocols, bool canUseThisType = false);
-    static std::string writeProperty(Meta::PropertyMeta* meta, Meta::BaseClassMeta* owner, bool optOutTypeChecking);
-    static std::string writeFunctionProto(const std::vector<Meta::Type*>& signature);
-    static std::string localizeReference(const std::string& jsName, std::string moduleName);
-    static std::string localizeReference(const Meta::Meta& meta);
-    static std::string tsifyType(const Meta::Type& type, const bool isParam = false);
-    static std::string computeMethodReturnType(const Meta::Type* retType, const Meta::BaseClassMeta* owner, bool canUseThisType = false);
-    std::string getTypeArgumentsStringOrEmpty(const clang::ObjCObjectType* objectType);
-
-    static bool hasClosedGenerics(const Meta::Type& type);
-
-    std::pair<clang::Module*, std::vector<Meta::Meta*> >& _module;
-    Meta::TypeFactory& _typeFactory;
-    DocSetManager _docSet;
-    std::unordered_set<std::string> _importedModules;
-    std::ostringstream _buffer;
+ public:
+  DefinitionWriter(std::pair<clang::Module*, std::vector<Meta::Meta*> >& module,
+                   Meta::TypeFactory& typeFactory, std::string docSetPath)
+      : _module(module), _typeFactory(typeFactory), _docSet(docSetPath) {}
+
+  std::string write();
+
+  static bool applyManualChanges;
+
+  virtual void visit(Meta::InterfaceMeta* meta) override;
+
+  virtual void visit(Meta::ProtocolMeta* meta) override;
+
+  virtual void visit(Meta::CategoryMeta* meta) override;
+
+  virtual void visit(Meta::FunctionMeta* meta) override;
+
+  virtual void visit(Meta::StructMeta* meta) override;
+
+  virtual void visit(Meta::UnionMeta* meta) override;
+
+  virtual void visit(Meta::EnumMeta* meta) override;
+
+  virtual void visit(Meta::VarMeta* meta) override;
+
+  virtual void visit(Meta::MethodMeta* meta) override;
+
+  virtual void visit(Meta::PropertyMeta* meta) override;
+
+  virtual void visit(Meta::EnumConstantMeta* meta) override;
+
+ private:
+  template <class Member>
+  using CompoundMemberMap =
+      std::map<std::string, std::pair<Meta::BaseClassMeta*, Member*> >;
+
+  void writeMembers(const std::vector<Meta::RecordField>& fields,
+                    std::vector<TSComment> fieldsComments);
+  void writeProperty(Meta::PropertyMeta* meta, Meta::BaseClassMeta* owner,
+                     Meta::InterfaceMeta* target,
+                     CompoundMemberMap<Meta::PropertyMeta> compoundProperties);
+
+  static void getInheritedMembersRecursive(
+      Meta::InterfaceMeta* interface,
+      CompoundMemberMap<Meta::MethodMeta>* staticMethods,
+      CompoundMemberMap<Meta::MethodMeta>* instanceMethods,
+      CompoundMemberMap<Meta::PropertyMeta>* staticProperties,
+      CompoundMemberMap<Meta::PropertyMeta>* instanceProperties);
+
+  static void getProtocolMembersRecursive(
+      Meta::ProtocolMeta* protocol,
+      CompoundMemberMap<Meta::MethodMeta>* staticMethods,
+      CompoundMemberMap<Meta::MethodMeta>* instanceMethods,
+      CompoundMemberMap<Meta::PropertyMeta>* staticProperties,
+      CompoundMemberMap<Meta::PropertyMeta>* instanceProperties,
+      std::unordered_set<Meta::ProtocolMeta*>& visitedProtocols);
+
+  static std::string writeConstructor(
+      const CompoundMemberMap<Meta::MethodMeta>::value_type& initializer,
+      const Meta::BaseClassMeta* owner);
+  static std::string writeMethod(Meta::MethodMeta* meta,
+                                 Meta::BaseClassMeta* owner,
+                                 bool canUseThisType = false);
+  static std::string writeMethod(
+      CompoundMemberMap<Meta::MethodMeta>::value_type& method,
+      Meta::BaseClassMeta* owner,
+      const std::unordered_set<Meta::ProtocolMeta*>& protocols,
+      bool canUseThisType = false);
+  static std::string writeProperty(Meta::PropertyMeta* meta,
+                                   Meta::BaseClassMeta* owner,
+                                   bool optOutTypeChecking);
+  static std::string writeFunctionProto(
+      const std::vector<Meta::Type*>& signature);
+  static std::string localizeReference(const std::string& jsName,
+                                       std::string moduleName);
+  static std::string localizeReference(const Meta::Meta& meta);
+  static std::string tsifyType(const Meta::Type& type,
+                               const bool isParam = false,
+                               const bool suppressNull = false);
+  static std::string computeMethodReturnType(const Meta::Type* retType,
+                                             const Meta::BaseClassMeta* owner,
+                                             bool canUseThisType = false);
+  std::string getTypeArgumentsStringOrEmpty(
+      const clang::ObjCObjectType* objectType);
+
+  static bool hasClosedGenerics(const Meta::Type& type);
+
+  std::pair<clang::Module*, std::vector<Meta::Meta*> >& _module;
+  Meta::TypeFactory& _typeFactory;
+  DocSetManager _docSet;
+  std::unordered_set<std::string> _importedModules;
+  std::ostringstream _buffer;
 };
-}
+}  // namespace TypeScript