LanguageServer: Enhance auto completion for override.

source/compiler-core/slang-json-native.cpp

@@ -205,6 +205,22 @@ SlangResult JSONToNativeConverter::convert(const JSONValue& in, const RttiInfo*
             *(UnownedStringSlice*)out = m_container->getString(in);
             return SLANG_OK;
         }
+    case RttiInfo::Kind::Optional:
+        {
+            if (in.getKind() == JSONValue::Kind::Null)
+            {
+                return SLANG_OK;
+            }
+            typedef List<Byte> Type;
+            const OptionalRttiInfo* optionalRttiInfo =
+                static_cast<const OptionalRttiInfo*>(rttiInfo);
+            auto hasValue = (uint8_t*)out;
+            *hasValue = 1;
+            return convert(
+                in,
+                optionalRttiInfo->m_elementType,
+                (uint8_t*)out + optionalRttiInfo->m_valueOffset);
+        }
     case RttiInfo::Kind::List:
         {
             if (in.getKind() == JSONValue::Kind::Null)
@@ -441,6 +457,24 @@ SlangResult NativeToJSONConverter::convert(const RttiInfo* rttiInfo, const void*
         {
             return SLANG_E_NOT_IMPLEMENTED;
         }
+    case RttiInfo::Kind::Optional:
+        {
+            const OptionalRttiInfo* optionalRttiInfo =
+                static_cast<const OptionalRttiInfo*>(rttiInfo);
+            auto hasValue = (const uint8_t*)in;
+            if (*hasValue)
+            {
+                return convert(
+                    optionalRttiInfo->m_elementType,
+                    (const uint8_t*)in + optionalRttiInfo->m_valueOffset,
+                    out);
+            }
+            else
+            {
+                out = JSONValue::makeNull();
+                return SLANG_OK;
+            }
+        }
     case RttiInfo::Kind::List:
         {
             const ListRttiInfo* listRttiInfo = static_cast<const ListRttiInfo*>(rttiInfo);

source/compiler-core/slang-json-value.h

@@ -8,6 +8,8 @@
 #include "slang-json-parser.h"
 #include "slang-source-loc.h"
 
+#include <optional>
+
 namespace Slang
 {
 
@@ -439,6 +441,39 @@ class JSONContainer : public RefObject
     List<JSONKeyValue> m_objectValues;
 };
 
+template<typename T>
+class JSONOptional
+{
+public:
+    bool hasValue = false;
+    T value;
+    JSONOptional() = default;
+    JSONOptional(std::nullopt_t) {}
+    JSONOptional(const T& inValue)
+        : hasValue(true), value(inValue)
+    {
+    }
+};
+
+template<typename T>
+struct GetRttiInfo<JSONOptional<T>>
+{
+    static const OptionalRttiInfo _make()
+    {
+        OptionalRttiInfo info;
+        info.init<JSONOptional<T>>(RttiInfo::Kind::Optional);
+        info.m_elementType = GetRttiInfo<T>::get();
+        info.m_valueOffset = (uint32_t)offsetof(JSONOptional<T>, value);
+        return info;
+    }
+    static const RttiInfo* get()
+    {
+        static const OptionalRttiInfo g_info = _make();
+        return &g_info;
+    }
+};
+
+
 class JSONBuilder : public JSONListener
 {
 public:

source/compiler-core/slang-language-server-protocol.cpp

@@ -522,6 +522,7 @@ static const StructRttiInfo _makeCompletionItemRtti()
     builder.addField("label", &obj.label, StructRttiInfo::Flag::Optional);
     builder.addField("detail", &obj.detail, StructRttiInfo::Flag::Optional);
     builder.addField("kind", &obj.kind, StructRttiInfo::Flag::Optional);
+    builder.addField("sortText", &obj.sortText, StructRttiInfo::Flag::Optional);
     builder.addField("documentation", &obj.documentation, StructRttiInfo::Flag::Optional);
     builder.addField("data", &obj.data, StructRttiInfo::Flag::Optional);
     builder.addField("commitCharacters", &obj.commitCharacters, StructRttiInfo::Flag::Optional);

source/compiler-core/slang-language-server-protocol.h

@@ -610,6 +610,13 @@ struct CompletionItem
      */
     String detail;
 
+    /**
+     * A string that should be used when comparing this item
+     * with other items. When omitted the label is used
+     * as the sort text for this item.
+     */
+    JSONOptional<String> sortText;
+
     /**
      * A human-readable string that represents a doc-comment.
      */

source/core/slang-rtti-info.h

@@ -181,7 +181,7 @@ struct RttiInfo
         Enum,
         List,
         Dictionary,
-
+        Optional,
         CountOf,
     };
 
@@ -296,6 +296,12 @@ SLANG_FORCE_INLINE StructRttiInfo::Flags combine(
     return StructRttiInfo::Flags(defaultValue) | flags;
 }
 
+struct OptionalRttiInfo : public RttiInfo
+{
+    const RttiInfo* m_elementType;
+    uint32_t m_valueOffset;
+};
+
 struct ListRttiInfo : public RttiInfo
 {
     const RttiInfo* m_elementType;

source/core/slang-rtti-util.cpp

@@ -336,6 +336,7 @@ RttiTypeFuncs RttiUtil::getDefaultTypeFuncs(const RttiInfo* rttiInfo)
     case RttiInfo::Kind::List:
         return ListFuncs::getFuncs();
     case RttiInfo::Kind::Struct:
+    case RttiInfo::Kind::Optional:
         return StructArrayFuncs::getFuncs();
     default:
         break;
@@ -556,6 +557,10 @@ static bool _isStructDefault(const StructRttiInfo* type, const void* src)
             const OtherRttiInfo* otherRttiInfo = static_cast<const OtherRttiInfo*>(rttiInfo);
             return otherRttiInfo->m_isDefaultFunc && otherRttiInfo->m_isDefaultFunc(rttiInfo, src);
         }
+    case RttiInfo::Kind::Optional:
+        {
+            return *(const bool*)src == (_getIntDefaultValue(defaultValue) != 0);
+        }
     default:
         {
             return false;
@@ -660,6 +665,11 @@ static bool _isStructDefault(const StructRttiInfo* type, const void* src)
 
             return true;
         }
+    case RttiInfo::Kind::Optional:
+        {
+            const OptionalRttiInfo* optionalRttiInfo = static_cast<const OptionalRttiInfo*>(type);
+            return canMemCpy(optionalRttiInfo->m_elementType);
+        }
     default:
         {
             return type->isBuiltIn();
@@ -723,6 +733,11 @@ static bool _isStructDefault(const StructRttiInfo* type, const void* src)
 
             return true;
         }
+    case RttiInfo::Kind::Optional:
+        {
+            const OptionalRttiInfo* optionalRttiInfo = static_cast<const OptionalRttiInfo*>(type);
+            return canZeroInit(optionalRttiInfo->m_elementType);
+        }
     default:
         {
             return type->isBuiltIn();
@@ -783,6 +798,11 @@ static bool _isStructDefault(const StructRttiInfo* type, const void* src)
             } while (structRttiInfo);
             return false;
         }
+    case RttiInfo::Kind::Optional:
+        {
+            const OptionalRttiInfo* optionalRttiInfo = static_cast<const OptionalRttiInfo*>(type);
+            return hasDtor(optionalRttiInfo->m_elementType);
+        }
     default:
         {
             return !type->isBuiltIn();
@@ -894,6 +914,19 @@ static bool _isStructDefault(const StructRttiInfo* type, const void* src)
 
             return;
         }
+    case RttiInfo::Kind::Optional:
+        {
+            const OptionalRttiInfo* optionalRttiInfo =
+                static_cast<const OptionalRttiInfo*>(rttiInfo);
+            ctorArray(typeMap, GetRttiInfo<bool>::get(), dst, stride, count);
+            ctorArray(
+                typeMap,
+                optionalRttiInfo->m_elementType,
+                dst + optionalRttiInfo->m_valueOffset,
+                stride,
+                count);
+            return;
+        }
     }
 
     SLANG_ASSERT(!"Unexpected");
@@ -1005,6 +1038,20 @@ static bool _isStructDefault(const StructRttiInfo* type, const void* src)
 
             return;
         }
+    case RttiInfo::Kind::Optional:
+        {
+            const OptionalRttiInfo* optionalRttiInfo =
+                static_cast<const OptionalRttiInfo*>(rttiInfo);
+            copyArray(typeMap, GetRttiInfo<bool>::get(), dst, src, stride, count);
+            copyArray(
+                typeMap,
+                optionalRttiInfo->m_elementType,
+                dst + optionalRttiInfo->m_valueOffset,
+                src + optionalRttiInfo->m_valueOffset,
+                stride,
+                count);
+            return;
+        }
     }
 
     SLANG_ASSERT(!"Unexpected");
@@ -1091,6 +1138,19 @@ static bool _isStructDefault(const StructRttiInfo* type, const void* src)
 
             return;
         }
+    case RttiInfo::Kind::Optional:
+        {
+            const OptionalRttiInfo* optionalRttiInfo =
+                static_cast<const OptionalRttiInfo*>(rttiInfo);
+            dtorArray(typeMap, GetRttiInfo<bool>::get(), dst, stride, count);
+            dtorArray(
+                typeMap,
+                optionalRttiInfo->m_elementType,
+                dst + optionalRttiInfo->m_valueOffset,
+                stride,
+                count);
+            return;
+        }
     }
 
     SLANG_ASSERT(!"Unexpected");

source/slang/slang-ast-decl.cpp

@@ -42,7 +42,8 @@ bool isInterfaceRequirement(Decl* decl)
     {
         if (as<InterfaceDecl>(ancestor))
             return true;
-
+        if (as<InterfaceDefaultImplDecl>(ancestor))
+            return false;
         if (as<ExtensionDecl>(ancestor))
             return false;
     }

source/slang/slang-ast-print.cpp

@@ -1313,17 +1313,15 @@ void ASTPrinter::addGenericParams(const DeclRef<GenericDecl>& genericDeclRef)
                 sb << ", ";
             first = false;
 
-            {
-                ScopePart scopePart(this, Part::Type::GenericParamValue);
-                sb << getText(genericValParam.getName());
-            }
-
-            sb << ":";
-
             {
                 ScopePart scopePart(this, Part::Type::GenericParamValueType);
                 addType(getType(m_astBuilder, genericValParam));
             }
+            sb << " ";
+            {
+                ScopePart scopePart(this, Part::Type::GenericParamValue);
+                sb << getText(genericValParam.getName());
+            }
         }
         else if (auto genericTypePackParam = paramDeclRef.as<GenericTypePackParamDecl>())
         {