feat: add more null types for types the runtime accept or returns as null (#363)

Author: edusperoni

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: