zeroc-ice 3.8.1 → 3.8.3

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.
@@ -108,7 +108,7 @@ Slice::validateMetadata(const UnitPtr& p, string_view prefix, map<string, Metada
             }
         }
         return nullopt;
-    },
+    };
     knownMetadata.emplace("deprecate", std::move(deprecatedInfo));
 
     // "format"
@@ -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;
 }
 
@@ -264,18 +283,18 @@ MetadataVisitor::validate(MetadataList metadata, const SyntaxTreeBasePtr& p, boo
     for (auto i = metadata.begin(); i != metadata.end();)
     {
         const string& directive = (*i)->directive();
+        const auto colonIndex = directive.find(':');
 
-        // If the directive contains a ':' character, but is for a different language than what we're checking,
-        // we mark it for removal, but perform no additional validation of it.
-        if (directive.find(':') != string::npos && directive.find(_language) != 0)
+        // Only check the metadata if it starts with the provided '_language' prefix, or is language agnostic.
+        if ((directive.find(_language) == 0 && colonIndex == _language.size()) || colonIndex == string::npos)
         {
-            i = metadata.erase(i);
+            // Check if the metadata is valid. If it's not, remove it to shield downstream logic from invalid inputs.
+            bool isValid = isMetadataValid(*i, p, isTypeContext);
+            i = isValid ? std::next(i, 1) : metadata.erase(i);
         }
         else
         {
-            // If the metadata is invalid, remove it. Otherwise we advance to the next metadata like normal.
-            bool isValid = isMetadataValid(*i, p, isTypeContext);
-            i = isValid ? std::next(i, 1) : metadata.erase(i);
+            i = metadata.erase(i); // This metadata isn't relevant to the target language; remove it.
         }
     }
 
@@ -445,7 +464,8 @@ MetadataVisitor::isMetadataValid(const MetadataPtr& metadata, const SyntaxTreeBa
         {
             // We make a special exception to uniqueness for metadata on forward declarations, since there can be
             // multiple forward declarations for the same entity, but they all share a single backing `MetadataList`.
-            // So for these types, even 'unique' metadata to appear multiple times, but we require them to be identical.
+            // So for these types, we let even 'unique' metadata appear multiple times, but we require them to be
+            // identical.
             if (dynamic_pointer_cast<ClassDecl>(p) || dynamic_pointer_cast<InterfaceDecl>(p))
             {
                 const MetadataPtr& previousMetadata = _seenDirectives[directive];

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;
     }
@@ -79,10 +79,10 @@ namespace
     /// Reports any naming conflicts between @p name and @p definitions.
     /// This should only be called for Slice elements that are _not_ defined at module scope.
     /// For example, this is fine to use for operations, enumerators, data members, and parameters.
-    /// For elements that are defined within directly within modules, `findContents` must be used instead.
+    /// For elements that are defined directly within modules, `findContents` must be used instead.
     /// @param name The name to check for conflicts.
     /// @param kind The kind of element that we're checking (only used for error messages).
-    /// @param definitions A list of definitions check @p name against.
+    /// @param definitions A list of definitions to check @p name against.
     /// @return @c false if there are no name conflicts, @c true otherwise.
     bool doesNameConflict(string_view name, string_view kind, const ContainedList& definitions)
     {
@@ -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"))
@@ -813,8 +865,8 @@ Slice::Contained::Contained(const ContainerPtr& container, string name) : _conta
 void
 Slice::Container::destroyContents()
 {
-    // Container has pointers to all it's contents (since it logically owns them).
-    // But each Contained also keeps a pointer to it's parent, creating a cycle.
+    // Container has pointers to all its contents (since it logically owns them).
+    // But each Contained also keeps a pointer to its parent, creating a cycle.
     // We need to break this cycle.
     for (const auto& i : _contents)
     {
@@ -947,7 +999,7 @@ Slice::Container::createClassDef(const string& name, int32_t id, const ClassDefP
     def->_declaration = decl;
     decl->_definition = def;
 
-    // Patch forward declarations which may of been created in other openings of this class' module.
+    // Patch forward declarations which may have been created in other openings of this class' module.
     for (const auto& q : matches)
     {
         dynamic_pointer_cast<ClassDecl>(q)->_definition = def;
@@ -1083,7 +1135,7 @@ Slice::Container::createInterfaceDef(const string& name, const InterfaceList& ba
     def->_declaration = decl;
     decl->_definition = def;
 
-    // Patch forward declarations which may of been created in other openings of this interface's module.
+    // Patch forward declarations which may have been created in other openings of this interface's module.
     for (const auto& q : matches)
     {
         dynamic_pointer_cast<InterfaceDecl>(q)->_definition = def;
@@ -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
@@ -3396,7 +3436,7 @@ Slice::Exception::createDataMember(
                 if (baseMember->name() == name)
                 {
                     ostringstream os;
-                    os << "data member '" << name << "' is already defined in a base exception";
+                    os << "data member '" << name << "' is already defined as a data member in a base exception";
                     unit()->error(os.str());
                     break;
                 }
@@ -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);
@@ -3953,24 +3993,33 @@ Slice::Enum::createEnumerator(const string& name, optional<int32_t> explicitValu
             ostringstream os;
             os << "value for enumerator '" << name << "' is out of range";
             unit()->error(os.str());
+            nextValue = numeric_limits<int32_t>::min(); // Wrap around to the minimum value.
+        }
+        else
+        {
+            // If the enumerator was not assigned an explicit value,
+            // we automatically assign it one more than the previous enumerator.
+            nextValue = _lastValue + 1;
         }
-        // If the enumerator was not assigned an explicit value,
-        // we automatically assign it one more than the previous enumerator.
-        nextValue = _lastValue + 1;
     }
 
-    // Check if the enumerator's value is already in use.
     bool checkForDuplicates = true;
-    if (nextValue > _maxValue)
-    {
-        _maxValue = nextValue;
-        checkForDuplicates = false;
-    }
-    if (nextValue < _minValue)
+    // Negative values indicate this is a bogus enumerator that is only created for error-recovery purposes.
+    if (nextValue >= 0)
     {
-        _minValue = nextValue;
-        checkForDuplicates = false;
+        if (nextValue > _maxValue)
+        {
+            _maxValue = nextValue;
+            checkForDuplicates = false;
+        }
+        if (nextValue < _minValue)
+        {
+            _minValue = nextValue;
+            checkForDuplicates = false;
+        }
     }
+
+    // Check if the enumerator's value is already in use.
     if (checkForDuplicates)
     {
         for (const auto& r : enumerators())
@@ -4038,7 +4087,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 +4228,7 @@ Slice::Parameter::setIsOutParam()
 }
 
 bool
-Slice::Parameter::optional() const
+Slice::Parameter::isOptional() const
 {
     return _optional;
 }
@@ -4226,7 +4275,7 @@ Slice::DataMember::type() const
 }
 
 bool
-Slice::DataMember::optional() const
+Slice::DataMember::isOptional() const
 {
     return _optional;
 }
@@ -4268,7 +4317,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 +4452,7 @@ Slice::Unit::currentLine() const
 }
 
 int
-Slice::Unit::setCurrentFile(std::string currentFile, int lineNumber)
+Slice::Unit::setCurrentFile(string currentFile, int lineNumber)
 {
     assert(!currentFile.empty());
 
@@ -4418,7 +4467,6 @@ Slice::Unit::setCurrentFile(std::string currentFile, int lineNumber)
         if (!IceInternal::fileExists(resolvedFilename))
         {
             // MCPP may report incorrect absolute paths when files are included using relative paths.
-            // See: https://github.com/zeroc-ice/ice/issues/4253
 
             // If the path is absolute but the file doesn't exist, treat it as relative to the current definition
             // context.
@@ -4689,12 +4737,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 +4832,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 +4861,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;
 }