zeroc-ice 3.8.2 → 3.8.3

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

@@ -108,7 +108,7 @@ Slice::validateMetadata(const UnitPtr& unit, string_view prefix, map<string, Met
             }
         }
         return nullopt;
-    },
+    };
     knownMetadata.emplace("deprecate", std::move(deprecatedInfo));
 
     // "format"
@@ -283,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.
         }
     }
 
@@ -464,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/Parser.cpp

@@ -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)
     {
@@ -865,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)
     {
@@ -999,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;
@@ -1135,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;
@@ -3436,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;
                 }
@@ -3993,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())
@@ -4458,7 +4467,6 @@ Slice::Unit::setCurrentFile(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.

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

@@ -87,7 +87,6 @@ namespace Slice
 
     using StringList = std::list<std::string>;
     using MetadataList = std::list<MetadataPtr>;
-    using TypeList = std::list<TypePtr>;
     using ContainedList = std::list<ContainedPtr>;
     using ModuleList = std::list<ModulePtr>;
     using ClassList = std::list<ClassDefPtr>;
@@ -401,7 +400,7 @@ namespace Slice
         /// @remark Equivalent to `mappedScope(separator, leading) + mappedName()`.
         [[nodiscard]] std::string mappedScoped(const std::string& separator, bool leading = false) const;
 
-        /// Returns the mapped scope that this element will be generated in in the target language.
+        /// Returns the mapped scope in which this element will be generated in the target language.
         /// @param separator This string will be used to separate scope segments.
         /// @param leading If true, the returned string will have a leading `separator` (defaults to false).
         [[nodiscard]] std::string mappedScope(const std::string& separator, bool leading = false) const;
@@ -510,7 +509,7 @@ namespace Slice
         /// The user should disambiguate by qualifying the type-reference as 'Outer::H'.
         void checkHasChangedMeaning(const std::string& name, ContainedPtr namedThing = nullptr);
 
-        /// Returns `true` if this container is the global scope (i.e. it's of type `Unit`), and `false` otherwise.
+        /// Returns `false` if this container is the global scope (i.e. it's of type `Unit`), and `true` otherwise.
         /// If false, we emit an error message. So this function should only be called for types which cannot appear at
         /// global scope... so everything except for `Module`s.
         bool checkForGlobalDefinition(const char* definitionKindPlural);
@@ -733,7 +732,7 @@ namespace Slice
         [[nodiscard]] ParameterPtr returnParameter(const std::string& name);
 
         /// Returns this operation's out parameters and return type sorted in this order: '(required..., optional...)'.
-        /// If the this operation's return type is non-void and non-optional, it is at the end of the 'required' list.
+        /// If this operation's return type is non-void and non-optional, it is at the end of the 'required' list.
         /// Otherwise, required parameters are kept in definition order and optional parameters are sorted by tag.
         ///
         /// For convenience, non-void return types are represented by a dummy `Parameter` in this list.

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

@@ -110,24 +110,16 @@ Slice::Preprocessor::create(const string& path, const string& fileName, const ve
 Slice::Preprocessor::Preprocessor(string path, const string& fileName, const vector<string>& args)
     : _path(std::move(path)),
       _fileName(fullPath(fileName)),
-      _shortFileName(fileName),
       _args(args)
 {
 }
 
 Slice::Preprocessor::~Preprocessor() { close(); }
 
-string
-Slice::Preprocessor::getFileName()
-{
-    return _fileName;
-}
-
 string
 Slice::Preprocessor::getBaseName()
 {
     string base(_fileName);
-    string suffix;
     string::size_type pos = base.rfind('.');
     if (pos != string::npos)
     {
@@ -256,11 +248,11 @@ Slice::Preprocessor::preprocess(const string& languageArg)
         char* buf = mcpp_get_mem_buffer(Out);
 
         //
-        // First try to open temporay file in tmp directory.
+        // First try to open a temporary file in the 'tmp' directory.
         //
 #ifdef _WIN32
         //
-        // We use an unique id as the tmp file name prefix to avoid problems with this code being called concurrently
+        // We use a unique id as the tmp file name prefix to avoid problems with this code being called concurrently
         // from several processes, otherwise there is a chance that two processes call _wtempnam before any of them
         // opens the file and they will end up using the same tmp file. We then open the file with O_EXCL to atomically
         // create it -- this closes the TOCTOU window between _wtempnam returning a name and our opening it. The
@@ -339,7 +331,7 @@ Slice::Preprocessor::checkInputFile()
     }
     if (suffix != ".ice")
     {
-        throw runtime_error(_path + ": error: input files must end with `.ice'");
+        throw runtime_error(_path + ": error: input files must end with '.ice'");
     }
 
     ifstream test(IceInternal::streamFilename(_fileName).c_str());

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

@@ -24,7 +24,6 @@ namespace Slice
         FILE* preprocess(const std::string& languageArg = "");
         void close();
 
-        std::string getFileName();
         std::string getBaseName();
 
         static std::string normalizeIncludePath(const std::string& path);
@@ -34,7 +33,6 @@ namespace Slice
 
         const std::string _path;
         const std::string _fileName;
-        const std::string _shortFileName;
         const std::vector<std::string> _args;
         FILE* _cppHandle{nullptr};
     };

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

@@ -1829,7 +1829,7 @@ YY_RULE_SETUP
 }
 	YY_BREAK
 /* Matches the end of a double-quoted string literal, but only while scanning a string literal. Flex always prefers
-   * to match the longest string it can, so quotes preceeded with a literal '\' will match the rules above this one. */
+   * to match the longest string it can, so quotes preceded with a literal '\' will match the rules above this one. */
 case 18:
 YY_RULE_SETUP
 #line 261 "src/Slice/Scanner.l"
@@ -2233,7 +2233,7 @@ YY_RULE_SETUP
     return BAD_TOKEN;
 }
 	YY_BREAK
-/* Matches any valid character (except newlines) not matched by another rule and fowards it to the parser.
+/* Matches any valid character (except newlines) not matched by another rule and forwards it to the parser.
    * This is the lowest priority rule in the scanner, and is only active while not in a sub-scanner. */
 case 50:
 YY_RULE_SETUP
@@ -3390,7 +3390,7 @@ namespace
         keywordMap["Value"] = ICE_VALUE;
     }
 
-    // This function is always called directly after a match has been made, but directly before it's action block is run.
+    // This function is always called directly after a match has been made, but directly before its action block is run.
     void preAction()
     {
         yycolno += yyleng;