zeroc-ice 3.8.1 → 3.8.2

data/dist/ice/cpp/src/Slice/DocCommentParser.cpp

@@ -60,9 +60,9 @@ DocCommentFormatter::formatCode(const string& rawText)
 }
 
 string
-DocCommentFormatter::formatParamRef(const string& param)
+DocCommentFormatter::formatParamRef(const string& paramName, const ParameterPtr&)
 {
-    return formatCode(param);
+    return formatCode(paramName);
 }
 
 string
@@ -397,19 +397,19 @@ namespace
         // Extract the parameter's name and check if matches an operation parameter.
         // If it does, make sure to use the mapped name instead of the Slice name.
         string parameterName = line.substr(nameStart, nameEnd - nameStart);
+        ParameterPtr parameterPtr = nullptr;
         if (auto operationTarget = dynamic_pointer_cast<Operation>(p))
         {
-            bool doesParameterExist = false;
             for (const auto& param : operationTarget->parameters())
             {
                 if (param->name() == parameterName)
                 {
                     parameterName = param->mappedName();
-                    doesParameterExist = true;
+                    parameterPtr = param;
                     break;
                 }
             }
-            if (!doesParameterExist)
+            if (parameterPtr == nullptr)
             {
                 string opName = operationTarget->name();
                 string msg = "No parameter named '" + parameterName + "' exists on operation '" + opName + "'";
@@ -422,7 +422,7 @@ namespace
         }
 
         // Format the parameter's name and insert it in-place of the original '@p name'.
-        const string formattedParamName = formatter.formatParamRef(parameterName);
+        const string formattedParamName = formatter.formatParamRef(parameterName, parameterPtr);
         line.erase(pos, nameEnd - pos);
         line.insert(pos, formattedParamName);
 

data/dist/ice/cpp/src/Slice/DocCommentParser.h

@@ -27,12 +27,14 @@ namespace Slice
         [[nodiscard]] virtual std::string formatCode(const std::string& rawText);
 
         /// This function is called by the doc-comment parser to map '@p' tags into each language's syntax.
-        /// @param param The mapped name of the parameter that is being referenced.
+        /// @param paramName If @p paramPtr is non-null, this is the mapped name of the parameter being referenced.
+        /// Otherwise, this is the identifier after '@p', taken verbatim from the doc-comment.
+        /// @param paramPtr A pointer to the parameter that is being referenced, or `nullptr` if it doesn't exist.
         /// @return A properly formatted parameters reference in the target language. The doc-comment parser will
         /// replace the entire "@p <rawParamName>" string with the returned value.
         //
         // By default we just emit the parameter's name in code formatting.
-        [[nodiscard]] virtual std::string formatParamRef(const std::string& param);
+        [[nodiscard]] virtual std::string formatParamRef(const std::string& paramName, const ParameterPtr& paramPtr);
 
         /// This function is called by the doc-comment parser to map doc-links ('{@link <rawLink>}') into each
         /// language's syntax.

data/dist/ice/cpp/src/Slice/MetadataValidation.cpp

@@ -67,7 +67,7 @@ Slice::misappliedMetadataMessage(const MetadataPtr& metadata, const SyntaxTreeBa
 }
 
 void
-Slice::validateMetadata(const UnitPtr& p, string_view prefix, map<string, MetadataInfo> knownMetadata)
+Slice::validateMetadata(const UnitPtr& unit, string_view prefix, map<string, MetadataInfo> knownMetadata)
 {
     // We want to perform all the metadata validation in the same pass, to keep all the diagnostics in order.
     // So, we add all the language-agnostic metadata validation into the provided list.
@@ -126,6 +126,25 @@ Slice::validateMetadata(const UnitPtr& p, string_view prefix, map<string, Metada
     };
     knownMetadata.emplace("marshaled-result", std::move(marshaledResultInfo));
 
+    // "oneway"
+    MetadataInfo onewayInfo = {
+        .validOn = {typeid(Operation)},
+        .acceptedArgumentKind = MetadataArgumentKind::NoArguments,
+        .extraValidation = [](const MetadataPtr&, const SyntaxTreeBasePtr& q) -> optional<string>
+        {
+            if (auto op = dynamic_pointer_cast<Operation>(q))
+            {
+                if (op->returnsData())
+                {
+                    return "'oneway' metadata cannot be applied to an operation that has a return type, out parameters,"
+                           " or an exception specification";
+                }
+            }
+            return nullopt;
+        },
+    };
+    knownMetadata.emplace("oneway", std::move(onewayInfo));
+
     // "suppress-warning"
     MetadataInfo suppressWarningInfo = {
         .validOn = {typeid(Unit)},
@@ -137,7 +156,7 @@ Slice::validateMetadata(const UnitPtr& p, string_view prefix, map<string, Metada
 
     // Then we pass this list off the internal visitor, which performs the heavy lifting.
     auto visitor = MetadataVisitor(prefix, std::move(knownMetadata));
-    p->visit(&visitor);
+    unit->visit(&visitor);
 }
 
 MetadataVisitor::MetadataVisitor(string_view language, map<string, MetadataInfo> knownMetadata)
@@ -148,11 +167,11 @@ MetadataVisitor::MetadataVisitor(string_view language, map<string, MetadataInfo>
 }
 
 bool
-MetadataVisitor::visitUnitStart(const UnitPtr& p)
+MetadataVisitor::visitUnitStart(const UnitPtr& unit)
 {
-    DefinitionContextPtr dc = p->findDefinitionContext(p->topLevelFile());
+    DefinitionContextPtr dc = unit->findDefinitionContext(unit->topLevelFile());
     assert(dc);
-    dc->setMetadata(validate(dc->getMetadata(), p));
+    dc->setMetadata(validate(dc->getMetadata(), unit));
     return true;
 }
 

data/dist/ice/cpp/src/Slice/MetadataValidation.h

@@ -95,12 +95,13 @@ namespace Slice
     std::string misappliedMetadataMessage(const MetadataPtr& metadata, const SyntaxTreeBasePtr& p);
 
     /// Validates all the metadata in the provided Unit against a map of known metadata.
-    /// @param p The unit who's metadata should be validated.
+    /// @param unit The unit whose metadata should be validated.
     /// @param prefix Which language's metadata should be validated. Any metadata that starts with a different
     ///               language prefix than this one will be ignored. Note that metadata without any language prefix
     ///               (i.e. parser metadata) is always checked.
     /// @param knownMetadata A map containing the directives that should be validated, and information describing
     ///                      the various constraints and conditions that should be upheld for it and its arguments.
-    void validateMetadata(const UnitPtr& p, std::string_view prefix, std::map<std::string, MetadataInfo> knownMetadata);
+    void
+    validateMetadata(const UnitPtr& unit, std::string_view prefix, std::map<std::string, MetadataInfo> knownMetadata);
 }
 #endif

data/dist/ice/cpp/src/Slice/Parser.cpp

@@ -48,7 +48,7 @@ namespace
     DataMemberList filterOrderedOptionalDataMembers(const DataMemberList& members)
     {
         DataMemberList result;
-        copy_if(members.begin(), members.end(), back_inserter(result), [](const auto& p) { return p->optional(); });
+        copy_if(members.begin(), members.end(), back_inserter(result), [](const auto& p) { return p->isOptional(); });
         result.sort(compareTag<DataMemberPtr>);
         return result;
     }
@@ -111,6 +111,58 @@ namespace
         }
         return true;
     }
+
+    /// Checks an identifier for illegal syntax and reports any errors that are present.
+    bool reportIllegalSuffixOrUnderscore(const string& identifier)
+    {
+        // check whether the identifier is scoped
+        size_t scopeIndex = identifier.rfind("::");
+        bool isScoped = scopeIndex != string::npos;
+        string name;
+        if (isScoped)
+        {
+            name = identifier.substr(scopeIndex + 2); // Only check the unscoped identifier for syntax
+        }
+        else
+        {
+            name = identifier;
+        }
+
+        assert(!name.empty());
+        bool isValid = true;
+
+        // check the identifier for reserved suffixes
+        static const string suffixBlacklist[] = {"Helper", "Holder", "Prx", "Ptr"};
+        for (const auto& i : suffixBlacklist)
+        {
+            if (name.find(i, name.size() - i.size()) != string::npos)
+            {
+                currentUnit->error("illegal identifier '" + name + "': '" + i + "' suffix is reserved");
+                isValid = false;
+                break;
+            }
+        }
+
+        // check the identifier for illegal underscores
+        size_t index = name.find('_');
+        if (index == 0)
+        {
+            currentUnit->error("illegal leading underscore in identifier '" + name + "'");
+            isValid = false;
+        }
+        else if (name.rfind('_') == (name.size() - 1))
+        {
+            currentUnit->error("illegal trailing underscore in identifier '" + name + "'");
+            isValid = false;
+        }
+        else if (name.find("__") != string::npos)
+        {
+            currentUnit->error("illegal double underscore in identifier '" + name + "'");
+            isValid = false;
+        }
+
+        return isValid;
+    }
 }
 
 namespace Slice
@@ -563,7 +615,7 @@ Slice::Builtin::kindAsString() const
     return builtinTable[_kind];
 }
 
-optional<Slice::Builtin::Kind>
+optional<Builtin::Kind>
 Slice::Builtin::kindFromString(string_view str)
 {
     // Object is an alias for Value that we don't put in the builtinTable.
@@ -749,7 +801,7 @@ Slice::Contained::getMetadataArgs(string_view directive) const
     return nullopt;
 }
 
-std::optional<FormatType>
+optional<FormatType>
 Slice::Contained::parseFormatMetadata() const
 {
     if (auto metadata = getMetadataArgs("format"))
@@ -1595,9 +1647,9 @@ Slice::Container::lookupInterfaceDef(const string& identifier, bool emitErrors)
     TypePtr resolvedType = lookupType(identifier);
     if (resolvedType)
     {
-        if (auto interface = dynamic_pointer_cast<InterfaceDecl>(resolvedType))
+        if (auto interfaceDecl = dynamic_pointer_cast<InterfaceDecl>(resolvedType))
         {
-            if (InterfaceDefPtr def = interface->definition())
+            if (InterfaceDefPtr def = interfaceDecl->definition())
             {
                 return def;
             }
@@ -2147,13 +2199,13 @@ Slice::Module::getTopLevelModule() const
         return parent->getTopLevelModule();
     }
     // Reaching here means that this module is at the top-level! We return it.
-    return dynamic_pointer_cast<Module>(const_pointer_cast<Container>(shared_from_this()));
+    return static_pointer_cast<Module>(const_pointer_cast<Container>(shared_from_this()));
 }
 
 void
 Slice::Module::visit(ParserVisitor* visitor)
 {
-    auto self = dynamic_pointer_cast<Module>(shared_from_this());
+    auto self = static_pointer_cast<Module>(shared_from_this());
     if (visitor->visitModuleStart(self))
     {
         visitContents(visitor);
@@ -2310,7 +2362,7 @@ Slice::ClassDef::createDataMember(
         // Validate the tag.
         for (const auto& q : dataMembers())
         {
-            if (q->optional() && tag == q->tag())
+            if (q->isOptional() && tag == q->tag())
             {
                 unit()->error("tag for optional data member '" + name + "' is already in use");
                 break;
@@ -2428,7 +2480,7 @@ Slice::ClassDef::kindOf() const
 void
 Slice::ClassDef::visit(ParserVisitor* visitor)
 {
-    auto self = dynamic_pointer_cast<ClassDef>(shared_from_this());
+    auto self = static_pointer_cast<ClassDef>(shared_from_this());
     if (visitor->visitClassDefStart(self))
     {
         visitContents(visitor);
@@ -2615,7 +2667,7 @@ Slice::InterfaceDecl::addPartition(
 // list of lists, with each member list containing the operation
 // names defined by the interfaces in each partition.
 //
-Slice::InterfaceDecl::StringPartitionList
+InterfaceDecl::StringPartitionList
 Slice::InterfaceDecl::toStringPartitionList(const GraphPartitionList& partitions)
 {
     StringPartitionList spl;
@@ -2738,8 +2790,9 @@ Slice::InterfaceDef::createOperation(
                 break;
             }
         }
-        // Check the operations of the Object pseudo-interface.
-        if (!checkBaseOperationNames(name, {"ice_id", "ice_ids", "ice_ping", "ice_isA"}))
+
+        // Check the operations of the Object pseudo-interface unless we're generating code for Object itself.
+        if (scoped() != "::Ice::Object" && !checkBaseOperationNames(name, {"ice_id", "ice_ids", "ice_ping", "ice_isA"}))
         {
             hasConflictingIdentifier = true;
         }
@@ -2827,6 +2880,24 @@ Slice::InterfaceDef::operations() const
 
 OperationList
 Slice::InterfaceDef::allOperations() const
+{
+    OperationList result = allInheritedOperations();
+
+    for (const auto& q : operations())
+    {
+        if (none_of(
+                result.begin(),
+                result.end(),
+                [name = q->name()](const auto& other) { return other->name() == name; }))
+        {
+            result.push_back(q);
+        }
+    }
+    return result;
+}
+
+OperationList
+Slice::InterfaceDef::allInheritedOperations() const
 {
     OperationList result;
     for (const auto& p : _bases)
@@ -2842,17 +2913,6 @@ Slice::InterfaceDef::allOperations() const
             }
         }
     }
-
-    for (const auto& q : operations())
-    {
-        if (none_of(
-                result.begin(),
-                result.end(),
-                [name = q->name()](const auto& other) { return other->name() == name; }))
-        {
-            result.push_back(q);
-        }
-    }
     return result;
 }
 
@@ -2865,7 +2925,7 @@ Slice::InterfaceDef::kindOf() const
 void
 Slice::InterfaceDef::visit(ParserVisitor* visitor)
 {
-    auto self = dynamic_pointer_cast<InterfaceDef>(shared_from_this());
+    auto self = static_pointer_cast<InterfaceDef>(shared_from_this());
     if (visitor->visitInterfaceDefStart(self))
     {
         visitContents(visitor);
@@ -2915,7 +2975,7 @@ Slice::InterfaceDef::InterfaceDef(const ContainerPtr& container, const string& n
 // ----------------------------------------------------------------------
 
 InterfaceDefPtr
-Slice::Operation::interface() const
+Slice::Operation::parentInterface() const
 {
     return dynamic_pointer_cast<InterfaceDef>(_container);
 }
@@ -2947,7 +3007,7 @@ Slice::Operation::mode() const
 bool
 Slice::Operation::hasMarshaledResult() const
 {
-    InterfaceDefPtr intf = interface();
+    InterfaceDefPtr intf = parentInterface();
     assert(intf);
     if (intf->hasMetadata("marshaled-result") || hasMetadata("marshaled-result"))
     {
@@ -2996,7 +3056,7 @@ Slice::Operation::createParameter(const string& name, const TypePtr& type, bool
         {
             for (const auto& param : parameters())
             {
-                if (param->optional() && param->tag() == tag)
+                if (param->isOptional() && param->tag() == tag)
                 {
                     unit()->error(msg);
                     break;
@@ -3028,12 +3088,11 @@ ParameterList
 Slice::Operation::inParameters() const
 {
     ParameterList result;
-    for (const auto& p : _contents)
+    for (const auto& p : parameters())
     {
-        ParameterPtr q = dynamic_pointer_cast<Parameter>(p);
-        if (q && !q->isOutParam())
+        if (!p->isOutParam())
         {
-            result.push_back(q);
+            result.push_back(p);
         }
     }
     return result;
@@ -3046,7 +3105,7 @@ Slice::Operation::sortedInParameters() const
     ParameterList required, optional;
     for (const auto& param : inParameters())
     {
-        if (param->optional())
+        if (param->isOptional())
         {
             optional.push_back(param);
         }
@@ -3068,12 +3127,11 @@ ParameterList
 Slice::Operation::outParameters() const
 {
     ParameterList result;
-    for (const auto& p : _contents)
+    for (const auto& p : parameters())
     {
-        ParameterPtr q = dynamic_pointer_cast<Parameter>(p);
-        if (q && q->isOutParam())
+        if (p->isOutParam())
         {
-            result.push_back(q);
+            result.push_back(p);
         }
     }
     return result;
@@ -3122,7 +3180,7 @@ Slice::Operation::sortedReturnAndOutParameters(const string& returnName)
     // First sort each parameter into either 'required' or 'optional'.
     for (auto i = required.begin(); i != required.end();)
     {
-        if ((*i)->optional())
+        if ((*i)->isOptional())
         {
             optional.push_back(*i);
             i = required.erase(i);
@@ -3193,9 +3251,9 @@ Slice::Operation::setExceptionList(const ExceptionList& exceptions)
 bool
 Slice::Operation::sendsClasses() const
 {
-    for (const auto& i : parameters())
+    for (const auto& i : inParameters())
     {
-        if (!i->isOutParam() && i->type()->usesClasses())
+        if (i->type()->usesClasses())
         {
             return true;
         }
@@ -3212,9 +3270,9 @@ Slice::Operation::returnsClasses() const
         return true;
     }
 
-    for (const auto& i : parameters())
+    for (const auto& i : outParameters())
     {
-        if (i->isOutParam() && i->type()->usesClasses())
+        if (i->type()->usesClasses())
         {
             return true;
         }
@@ -3225,25 +3283,7 @@ Slice::Operation::returnsClasses() const
 bool
 Slice::Operation::returnsData() const
 {
-    TypePtr t = returnType();
-    if (t)
-    {
-        return true;
-    }
-
-    for (const auto& i : parameters())
-    {
-        if (i->isOutParam())
-        {
-            return true;
-        }
-    }
-
-    if (!throws().empty())
-    {
-        return true;
-    }
-    return false;
+    return returnsAnyValues() || !throws().empty();
 }
 
 bool
@@ -3270,7 +3310,7 @@ Slice::Operation::sendsOptionals() const
 {
     for (const auto& i : inParameters())
     {
-        if (i->optional())
+        if (i->isOptional())
         {
             return true;
         }
@@ -3283,7 +3323,7 @@ Slice::Operation::receivesOptionals() const
 {
     for (const auto& i : outParameters())
     {
-        if (i->optional())
+        if (i->isOptional())
         {
             return true;
         }
@@ -3291,10 +3331,10 @@ Slice::Operation::receivesOptionals() const
     return returnIsOptional();
 }
 
-std::optional<FormatType>
+optional<FormatType>
 Slice::Operation::format() const
 {
-    std::optional<FormatType> format = parseFormatMetadata();
+    optional<FormatType> format = parseFormatMetadata();
     if (!format)
     {
         ContainedPtr cont = dynamic_pointer_cast<Contained>(container());
@@ -3313,7 +3353,7 @@ Slice::Operation::kindOf() const
 void
 Slice::Operation::visit(ParserVisitor* visitor)
 {
-    visitor->visitOperation(dynamic_pointer_cast<Operation>(shared_from_this()));
+    visitor->visitOperation(static_pointer_cast<Operation>(shared_from_this()));
 }
 
 void
@@ -3419,7 +3459,7 @@ Slice::Exception::createDataMember(
         // Validate the tag.
         for (const auto& q : dataMembers())
         {
-            if (q->optional() && tag == q->tag())
+            if (q->isOptional() && tag == q->tag())
             {
                 unit()->error("tag for optional data member '" + name + "' is already in use");
                 break;
@@ -3549,7 +3589,7 @@ Slice::Exception::kindOf() const
 void
 Slice::Exception::visit(ParserVisitor* visitor)
 {
-    auto self = dynamic_pointer_cast<Exception>(shared_from_this());
+    auto self = static_pointer_cast<Exception>(shared_from_this());
     if (visitor->visitExceptionStart(self))
     {
         visitContents(visitor);
@@ -3704,7 +3744,7 @@ Slice::Struct::kindOf() const
 void
 Slice::Struct::visit(ParserVisitor* visitor)
 {
-    auto self = dynamic_pointer_cast<Struct>(shared_from_this());
+    auto self = static_pointer_cast<Struct>(shared_from_this());
     if (visitor->visitStructStart(self))
     {
         visitContents(visitor);
@@ -4038,7 +4078,7 @@ Slice::Enum::kindOf() const
 void
 Slice::Enum::visit(ParserVisitor* visitor)
 {
-    visitor->visitEnum(dynamic_pointer_cast<Enum>(shared_from_this()));
+    visitor->visitEnum(static_pointer_cast<Enum>(shared_from_this()));
 }
 
 void
@@ -4179,7 +4219,7 @@ Slice::Parameter::setIsOutParam()
 }
 
 bool
-Slice::Parameter::optional() const
+Slice::Parameter::isOptional() const
 {
     return _optional;
 }
@@ -4226,7 +4266,7 @@ Slice::DataMember::type() const
 }
 
 bool
-Slice::DataMember::optional() const
+Slice::DataMember::isOptional() const
 {
     return _optional;
 }
@@ -4268,7 +4308,7 @@ Slice::DataMember::DataMember(
     bool isOptional,
     int32_t tag,
     SyntaxTreeBasePtr defaultValueType,
-    std::optional<string> defaultValueString)
+    optional<string> defaultValueString)
     : Contained(container, name),
       _type(std::move(type)),
       _optional(isOptional),
@@ -4403,7 +4443,7 @@ Slice::Unit::currentLine() const
 }
 
 int
-Slice::Unit::setCurrentFile(std::string currentFile, int lineNumber)
+Slice::Unit::setCurrentFile(string currentFile, int lineNumber)
 {
     assert(!currentFile.empty());
 
@@ -4689,12 +4729,12 @@ Slice::Unit::findContents(const string& scopedName) const
 }
 
 void
-Slice::Unit::addTypeId(int32_t compactId, const std::string& typeId)
+Slice::Unit::addTypeId(int32_t compactId, const string& typeId)
 {
     _typeIds.insert(make_pair(compactId, typeId));
 }
 
-std::string
+string
 Slice::Unit::getTypeId(int32_t compactId) const
 {
     auto p = _typeIds.find(compactId);
@@ -4784,7 +4824,7 @@ Slice::Unit::destroy()
 void
 Slice::Unit::visit(ParserVisitor* visitor)
 {
-    auto self = dynamic_pointer_cast<Unit>(shared_from_this());
+    auto self = static_pointer_cast<Unit>(shared_from_this());
     if (visitor->visitUnitStart(self))
     {
         visitContents(visitor);
@@ -4813,7 +4853,7 @@ Slice::Unit::createBuiltin(Builtin::Kind kind)
     {
         return p->second;
     }
-    auto builtin = make_shared<Builtin>(dynamic_pointer_cast<Unit>(shared_from_this()), kind);
+    auto builtin = make_shared<Builtin>(static_pointer_cast<Unit>(shared_from_this()), kind);
     _builtins.insert(make_pair(kind, builtin));
     return builtin;
 }

data/dist/ice/cpp/src/Slice/Parser.h

@@ -692,8 +692,15 @@ namespace Slice
             Idempotent = 2
         };
 
-        Operation(const ContainerPtr&, const std::string&, TypePtr, bool, std::int32_t, Mode);
-        [[nodiscard]] InterfaceDefPtr interface() const;
+        Operation(
+            const ContainerPtr& container,
+            const std::string& name,
+            TypePtr returnType,
+            bool returnIsOptional,
+            std::int32_t returnTag,
+            Mode mode);
+
+        [[nodiscard]] InterfaceDefPtr parentInterface() const;
         [[nodiscard]] TypePtr returnType() const;
         [[nodiscard]] bool returnIsOptional() const;
         [[nodiscard]] std::int32_t returnTag() const;
@@ -740,12 +747,19 @@ namespace Slice
 
         [[nodiscard]] ExceptionList throws() const;
         void setExceptionList(const ExceptionList& exceptions);
+
+        /// Returns true if this operation uses class types in any of its in parameters.
         [[nodiscard]] bool sendsClasses() const;
+
+        /// Returns true if this operation uses class types in its return type, or any of its out parameters.
         [[nodiscard]] bool returnsClasses() const;
+
+        /// Returns true if this operation has any out parameters, a non-void return type, or can throw any exceptions.
         [[nodiscard]] bool returnsData() const;
 
         /// Returns true if this operation has any out parameters or a non-void return type.
         [[nodiscard]] bool returnsAnyValues() const;
+
         /// Returns true if this operation's output parameters, plus any non-void return type, is greater than 1.
         [[nodiscard]] bool returnsMultipleValues() const;
 
@@ -792,6 +806,7 @@ namespace Slice
         [[nodiscard]] InterfaceList allBases() const;
         [[nodiscard]] OperationList operations() const;
         [[nodiscard]] OperationList allOperations() const;
+        [[nodiscard]] OperationList allInheritedOperations() const;
         [[nodiscard]] std::string kindOf() const final;
         void visit(ParserVisitor* visitor) final;
 
@@ -1019,7 +1034,7 @@ namespace Slice
         [[nodiscard]] TypePtr type() const;
         [[nodiscard]] bool isOutParam() const;
         void setIsOutParam();
-        [[nodiscard]] bool optional() const;
+        [[nodiscard]] bool isOptional() const;
         [[nodiscard]] std::int32_t tag() const;
         [[nodiscard]] std::string kindOf() const final;
 
@@ -1048,7 +1063,7 @@ namespace Slice
             SyntaxTreeBasePtr defaultValueType,
             std::optional<std::string> defaultValueString);
         [[nodiscard]] TypePtr type() const;
-        [[nodiscard]] bool optional() const;
+        [[nodiscard]] bool isOptional() const;
         [[nodiscard]] std::int32_t tag() const;
 
         // defaultValue() and defaultValueType() are either both null (no default value) or both non-null.