zeroc-ice 3.8.0 → 3.8.2

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

@@ -6,6 +6,7 @@
 #include <array>
 #include <cstdint>
 #include <functional>
+#include <limits>
 #include <list>
 #include <map>
 #include <memory>
@@ -390,6 +391,10 @@ namespace Slice
         /// Returns the mapped identifier that this element will use in the target language.
         [[nodiscard]] std::string mappedName() const;
 
+        /// Returns the mapped name for this element in the target language if it has been customized with the
+        /// 'lang:name' metadata, or `nullopt` if it doesn't have a custom name.
+        [[nodiscard]] std::optional<std::string> customMappedName() const;
+
         /// Returns the mapped fully-scoped identifier that this element will use 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).
@@ -476,8 +481,8 @@ namespace Slice
             MetadataList metadata,
             const SyntaxTreeBasePtr& valueType,
             const std::string& value);
-        [[nodiscard]] TypeList lookupType(const std::string& identifier);
-        [[nodiscard]] TypeList
+        [[nodiscard]] TypePtr lookupType(const std::string& identifier);
+        [[nodiscard]] TypePtr
         lookupTypeNoBuiltin(const std::string& identifier, bool emitErrors, bool ignoreUndefined = false);
         [[nodiscard]] ContainedList lookupContained(const std::string& identifier, bool emitErrors);
         [[nodiscard]] InterfaceDefPtr lookupInterfaceDef(const std::string& identifier, bool emitErrors);
@@ -687,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;
@@ -735,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;
 
@@ -787,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;
 
@@ -943,7 +963,7 @@ namespace Slice
 
     private:
         bool _hasExplicitValues{false};
-        std::int32_t _minValue;
+        std::int32_t _minValue{std::numeric_limits<std::int32_t>::max()};
         std::int32_t _maxValue{0};
         std::int32_t _lastValue{-1};
     };
@@ -1014,9 +1034,10 @@ 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;
+
         void visit(ParserVisitor* visitor) final;
 
     private:
@@ -1042,13 +1063,14 @@ 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.
         [[nodiscard]] std::optional<std::string> defaultValue() const;
         [[nodiscard]] SyntaxTreeBasePtr defaultValueType() const;
         [[nodiscard]] std::string kindOf() const final;
+
         void visit(ParserVisitor* visitor) final;
 
     private:
@@ -1063,14 +1085,26 @@ namespace Slice
     // Unit
     // ----------------------------------------------------------------------
 
+    /// Options for creating a Unit.
+    struct UnitOptions
+    {
+        /// When true, generate code for Slice definitions in included files.
+        bool all{false};
+
+        /// Provides a function that returns the default mapped name for a Contained element. nullptr, the default,
+        /// is equivalent to using the element's Slice name as its mapped name.
+        std::function<std::string(const Contained&)> defaultMappedName{nullptr};
+    };
+
     class Unit final : public Container
     {
     public:
-        static UnitPtr createUnit(std::string languageName, bool all);
+        static UnitPtr createUnit(std::string languageName, UnitOptions options = {});
 
-        Unit(std::string languageName, bool all);
+        Unit(std::string languageName, UnitOptions options);
 
         [[nodiscard]] std::string languageName() const;
+        [[nodiscard]] std::string defaultMappedName(const Contained& contained) const;
 
         /// Sets `_currentDocComment` to the provided string, erasing anything currently stored in it.
         /// @param comment The raw comment string. It can span multiple lines and include comment formatting characters
@@ -1154,6 +1188,7 @@ namespace Slice
 
         const std::string _languageName;
         bool _all;
+        std::function<std::string(const Contained&)> _defaultMappedName;
         int _errors{0};
         std::string _currentDocComment;
         int _currentIncludeLevel{0};

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

@@ -9,21 +9,80 @@
 #include "Util.h"
 #include <algorithm>
 #include <cassert>
+#include <cerrno>
 #include <cstring>
+#include <fcntl.h>
 #include <fstream>
 #include <iterator>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <vector>
 
-#ifndef _WIN32
+#ifdef _WIN32
+#    include <io.h>
+#    include <share.h>
+#else
 #    include <sys/wait.h>
+#    include <unistd.h>
 #endif
 
 using namespace std;
 using namespace Slice;
 using namespace IceInternal;
 
+namespace
+{
+    // Atomically create and open a new file for read/write, failing if the file already exists or, on POSIX, if the
+    // path resolves to a symlink. This avoids the TOCTOU race that a name-then-open sequence would otherwise expose
+    // to a local attacker who could plant a symlink at the generated path.
+#ifdef _WIN32
+    FILE* openExclusive(const wchar_t* path)
+    {
+        int fd = -1;
+        // _O_TEMPORARY tells the CRT to delete the file when the last file descriptor is closed -- this avoids the
+        // need for a separate, racy unlink-by-name in close().
+        if (::_wsopen_s(
+                &fd,
+                path,
+                _O_RDWR | _O_CREAT | _O_EXCL | _O_BINARY | _O_TEMPORARY,
+                _SH_DENYRW,
+                _S_IREAD | _S_IWRITE) != 0)
+        {
+            return nullptr;
+        }
+        FILE* fp = ::_fdopen(fd, "w+");
+        if (!fp)
+        {
+            ::_close(fd);
+        }
+        return fp;
+    }
+#else
+    FILE* openExclusive(const char* path)
+    {
+        int fd = ::open(path, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW, S_IRUSR | S_IWUSR);
+        if (fd == -1)
+        {
+            return nullptr;
+        }
+        // Unlink immediately so the file is anonymous: the inode survives via our descriptor and the kernel
+        // releases it on close. ENOENT means another process already removed the entry, leaving us in the same
+        // state; any other unlink error is fatal because the caller has no path to retry cleanup.
+        if (::unlink(path) != 0 && errno != ENOENT)
+        {
+            ::close(fd);
+            return nullptr;
+        }
+        FILE* fp = ::fdopen(fd, "w+");
+        if (!fp)
+        {
+            ::close(fd);
+        }
+        return fp;
+    }
+#endif
+}
+
 //
 // mcpp defines
 //
@@ -86,7 +145,7 @@ Slice::Preprocessor::normalizeIncludePath(const string& path)
     //
     // MCPP does not handle "-IC:/" well as an include path.
     //
-    if (path.size() != 3 || !(path[0] >= 'A' && path[0] <= 'Z') || (path[0] >= 'a' && path[0] <= 'z') ||
+    if (path.size() != 3 || !((path[0] >= 'A' && path[0] <= 'Z') || (path[0] >= 'a' && path[0] <= 'z')) ||
         path[1] != ':' || path[2] != '\\')
 #endif
     {
@@ -201,32 +260,32 @@ Slice::Preprocessor::preprocess(const string& languageArg)
         //
 #ifdef _WIN32
         //
-        // We use an unique id as the tmp file name prefix to avoid
-        // problems with this code being called concurrently from
-        // several processes, otherwise there is a change that two
-        // process call _tempnam before any of them call fopen and
-        // they will end up using the same tmp file.
+        // We use an 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
+        // _O_TEMPORARY flag inside openExclusive causes the file to be deleted automatically when the descriptor is
+        // closed, so we don't need to retain the path past this point.
         //
         wchar_t* name = _wtempnam(0, Ice::stringToWstring("slice-" + Ice::generateUUID()).c_str());
         if (name)
         {
-            _cppFile = Ice::wstringToString(name);
+            _cppHandle = openExclusive(name);
             free(name);
-            _cppHandle = IceInternal::fopen(_cppFile, "w+");
         }
 #else
         _cppHandle = tmpfile();
 #endif
 
-        // If that fails try to open file in current directory.
+        // If that fails try to open file in current directory. openExclusive immediately unlinks the file on POSIX
+        // and sets _O_TEMPORARY on Windows, so the path is only used during the open attempt.
         if (_cppHandle == nullptr)
         {
 #ifdef _WIN32
-            _cppFile = "slice-" + Ice::generateUUID();
+            _cppHandle = openExclusive(Ice::stringToWstring("slice-" + Ice::generateUUID()).c_str());
 #else
-            _cppFile = ".slice-" + Ice::generateUUID();
+            _cppHandle = openExclusive((".slice-" + Ice::generateUUID()).c_str());
 #endif
-            _cppHandle = IceInternal::fopen(_cppFile, "w+");
         }
 
         if (_cppHandle != nullptr)
@@ -241,7 +300,7 @@ Slice::Preprocessor::preprocess(const string& languageArg)
         {
             // Calling this again causes the memory buffers to be freed.
             mcpp_use_mem_buffers(1);
-            throw runtime_error(_path + ": error: could not open temporary file: " + _cppFile);
+            throw runtime_error(_path + ": error: could not open temporary file for preprocessor output");
         }
     }
 
@@ -256,14 +315,11 @@ Slice::Preprocessor::close()
 {
     if (_cppHandle != nullptr)
     {
+        // The temp file deletes itself when the descriptor is closed. On POSIX, tmpfile() returns an
+        // already-unlinked file and the CWD fallback unlinks after open; on Windows, openExclusive opens
+        // with _O_TEMPORARY. fclose is the only cleanup needed.
         int status = fclose(_cppHandle);
         _cppHandle = nullptr;
-
-        if (_cppFile.size() != 0)
-        {
-            IceInternal::unlink(_cppFile);
-        }
-
         if (status != 0)
         {
             throw runtime_error("failed to close preprocessor file: " + IceInternal::lastErrorToString());

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

@@ -36,7 +36,6 @@ namespace Slice
         const std::string _fileName;
         const std::string _shortFileName;
         const std::vector<std::string> _args;
-        std::string _cppFile;
         FILE* _cppHandle{nullptr};
     };
 }

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

@@ -1895,7 +1895,7 @@ YY_RULE_SETUP
     {
         literal = literal.substr(0, literal.size() - 1);    // Clobber trailing 'f' or 'F' suffix
     }
-    ftp->v = strtod(literal.c_str(), 0);
+    ftp->v = strtod(literal.c_str(), nullptr);
     if ((ftp->v == HUGE_VAL || ftp->v == -HUGE_VAL) && errno == ERANGE)
     {
         currentUnit->error("floating-point constant '" + string{yytext} + "' too large (overflow)");

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

@@ -7,6 +7,7 @@
 #include "Util.h"
 #include <algorithm>
 #include <cassert>
+#include <cctype>
 #include <climits>
 #include <cstring>
 
@@ -239,6 +240,43 @@ Slice::dirName(const string& path)
     }
 }
 
+string
+Slice::toPascalCase(const string& s)
+{
+    string result;
+    result.reserve(s.size());
+    bool capitalizeNext = true;
+    for (char c : s)
+    {
+        if (c == '_')
+        {
+            capitalizeNext = true;
+            // and consume this underscore
+        }
+        else if (capitalizeNext)
+        {
+            result += static_cast<char>(toupper(static_cast<unsigned char>(c)));
+            capitalizeNext = false;
+        }
+        else
+        {
+            result += c;
+        }
+    }
+    return result;
+}
+
+string
+Slice::toCamelCase(const string& s)
+{
+    string result = toPascalCase(s);
+    if (!result.empty())
+    {
+        result[0] = static_cast<char>(tolower(static_cast<unsigned char>(result[0])));
+    }
+    return result;
+}
+
 void
 Slice::emitError(string_view file, int line, string_view message)
 {
@@ -451,7 +489,7 @@ Slice::getArticleFor(const string& s)
     return (vowels.find_first_of(s[0]) != string::npos) ? "an" : "a";
 }
 
-std::string
+string
 Slice::pluralKindOf(const ContainedPtr& p)
 {
     string kindOf = p->kindOf();
@@ -469,58 +507,6 @@ Slice::pluralKindOf(const ContainedPtr& p)
     }
 }
 
-bool
-Slice::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;
-}
-
 bool
 Slice::isProxyType(const TypePtr& type)
 {
@@ -597,7 +583,7 @@ Slice::getFirstSentence(const StringList& lines)
 }
 
 string
-Slice::getEscapedParamName(const ParameterList& params, std::string_view param)
+Slice::getEscapedParamName(const ParameterList& params, string_view param)
 {
     for (const auto& p : params)
     {
@@ -612,14 +598,14 @@ Slice::getEscapedParamName(const ParameterList& params, std::string_view param)
 string
 Slice::getTypeScopedName(const TypePtr& type)
 {
-    if (auto builtin = std::dynamic_pointer_cast<Builtin>(type))
+    if (auto builtin = dynamic_pointer_cast<Builtin>(type))
     {
         return builtin->kindAsString();
     }
     else
     {
         // a type is either built-in or contained
-        auto contained = std::dynamic_pointer_cast<Contained>(type);
+        auto contained = dynamic_pointer_cast<Contained>(type);
         assert(contained);
         return contained->scoped();
     }
@@ -717,7 +703,7 @@ Slice::DependencyGenerator::writeMakefileDependencies(
 }
 
 void
-Slice::DependencyGenerator::writeXMLDependencies(const std::string& dependFile)
+Slice::DependencyGenerator::writeXMLDependencies(const string& dependFile)
 {
     ostringstream os;
     os << R"(<?xml version="1.0" encoding="UTF-8"?>)";
@@ -739,7 +725,7 @@ Slice::DependencyGenerator::writeXMLDependencies(const std::string& dependFile)
 }
 
 void
-Slice::DependencyGenerator::writeJSONDependencies(const std::string& dependFile)
+Slice::DependencyGenerator::writeJSONDependencies(const string& dependFile)
 {
     ostringstream os;
     os << "{";

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

@@ -48,21 +48,14 @@ namespace
         EscapeMode escapeMode,
         unsigned char cutOff)
         : _nonPrintableEscaped(std::move(nonPrintableEscaped)),
-          _printableEscaped(printableEscaped + "\\"),
+          // Double quotes don't need to be escaped in Matlab because the string delimiter is a single quote.
+          _printableEscaped(printableEscaped + "\\" + (escapeMode != Matlab ? "\"" : "")),
           _escapeMode(escapeMode),
           _cutOff(cutOff),
           _shortUCNPrefix(escapeMode == Matlab ? "\\x" : "\\u"),
           _octalChars("01234567"),
-          _hexChars("01234567890ABCDEFabcdef")
-
+          _hexChars("0123456789ABCDEFabcdef")
     {
-        //
-        // Double quotes don't need to be escaped in Matlab because the string delimiter is a single quote.
-        //
-        if (_escapeMode != Matlab)
-        {
-            const_cast<string&>(_printableEscaped) += '"';
-        }
     }
 
     string StringLiteralGenerator::escapeASCIIChar(char c)

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

@@ -14,6 +14,13 @@ namespace Slice
     std::string removeExtension(const std::string& path);
     std::string baseName(const std::string& path);
     std::string dirName(const std::string& path);
+
+    /// Converts a string to Pascal case. For example, "myClass" becomes "MyClass".
+    std::string toPascalCase(const std::string& s);
+
+    /// Converts a string to camel case. For example, "MyClass" becomes "myClass".
+    std::string toCamelCase(const std::string& s);
+
     void emitError(std::string_view file, int line, std::string_view message);
     void emitWarning(std::string_view file, int line, std::string_view message);
     void emitRaw(const char* message);
@@ -63,9 +70,6 @@ namespace Slice
     /// @see Contained::kindOf
     std::string pluralKindOf(const ContainedPtr& p);
 
-    // Checks an identifier for illegal syntax and reports any errors that are present.
-    bool reportIllegalSuffixOrUnderscore(const std::string& identifier);
-
     bool isProxyType(const TypePtr& type);
 
     // Is this the first element defined in its container?

data/dist/ice/cpp/src/slice2rb/Main.cpp

@@ -22,12 +22,12 @@ main(int argc, char* argv[])
     }
     catch (const std::exception& ex)
     {
-        consoleErr << args[0] << ": error:" << ex.what() << endl;
+        consoleErr << args[0] << ": error: " << ex.what() << endl;
         return EXIT_FAILURE;
     }
     catch (...)
     {
-        consoleErr << args[0] << ": error:unknown exception" << endl;
+        consoleErr << args[0] << ": error: unknown exception" << endl;
         return EXIT_FAILURE;
     }
 }

data/dist/ice/cpp/src/slice2rb/Ruby.cpp

@@ -156,7 +156,7 @@ Slice::Ruby::compile(const vector<string>& argv)
                 return EXIT_FAILURE;
             }
 
-            unit = Unit::createUnit("ruby", all);
+            unit = Unit::createUnit("ruby", {.all = all});
             int parseStatus = unit->parse(fileName, preprocessedHandle, debug);
 
             preprocessor->close();

data/dist/ice/cpp/src/slice2rb/RubyUtil.cpp

@@ -241,13 +241,14 @@ Slice::Ruby::CodeVisitor::visitClassDefStart(const ClassDefPtr& p)
     }
     for (auto q = members.begin(); q != members.end(); ++q)
     {
+        const bool isOptional = (*q)->isOptional();
         if (q != members.begin())
         {
             _out << ',' << nl;
         }
         _out << "['" << getMappedName(*q) << "', ";
         writeType((*q)->type());
-        _out << ", " << ((*q)->optional() ? "true" : "false") << ", " << ((*q)->optional() ? (*q)->tag() : 0) << ']';
+        _out << ", " << (isOptional ? "true" : "false") << ", " << (isOptional ? (*q)->tag() : 0) << ']';
     }
     if (members.size() > 1)
     {
@@ -407,6 +408,7 @@ Slice::Ruby::CodeVisitor::visitInterfaceDefStart(const InterfaceDefPtr& p)
         bool isFirst = true;
         for (const auto& param : op->inParameters())
         {
+            const bool isOptional = param->isOptional();
             if (!isFirst)
             {
                 _out << ", ";
@@ -414,13 +416,13 @@ Slice::Ruby::CodeVisitor::visitInterfaceDefStart(const InterfaceDefPtr& p)
             isFirst = false;
             _out << '[';
             writeType(param->type());
-            _out << ", " << (param->optional() ? "true" : "false") << ", " << (param->optional() ? param->tag() : 0)
-                 << ']';
+            _out << ", " << (isOptional ? "true" : "false") << ", " << (isOptional ? param->tag() : 0) << ']';
         }
         _out << "], [";
         isFirst = true;
         for (const auto& param : op->outParameters())
         {
+            const bool isOptional = param->isOptional();
             if (!isFirst)
             {
                 _out << ", ";
@@ -428,8 +430,7 @@ Slice::Ruby::CodeVisitor::visitInterfaceDefStart(const InterfaceDefPtr& p)
             isFirst = false;
             _out << '[';
             writeType(param->type());
-            _out << ", " << (param->optional() ? "true" : "false") << ", " << (param->optional() ? param->tag() : 0)
-                 << ']';
+            _out << ", " << (isOptional ? "true" : "false") << ", " << (isOptional ? param->tag() : 0) << ']';
         }
         _out << "], ";
         TypePtr returnType = op->returnType();
@@ -456,6 +457,7 @@ Slice::Ruby::CodeVisitor::visitInterfaceDefStart(const InterfaceDefPtr& p)
             _out << getMetaTypeReference(ex);
         }
         _out.epar("]");
+        _out << ", " << (op->hasMetadata("oneway") ? "true" : "false");
         _out << ")";
 
         if (op->isDeprecated())
@@ -547,14 +549,14 @@ Slice::Ruby::CodeVisitor::visitExceptionStart(const ExceptionPtr& p)
     //
     for (auto dmli = members.begin(); dmli != members.end(); ++dmli)
     {
+        const bool isOptional = (*dmli)->isOptional();
         if (dmli != members.begin())
         {
             _out << ',' << nl;
         }
         _out << "[\"" << getMappedName(*dmli) << "\", ";
         writeType((*dmli)->type());
-        _out << ", " << ((*dmli)->optional() ? "true" : "false") << ", " << ((*dmli)->optional() ? (*dmli)->tag() : 0)
-             << ']';
+        _out << ", " << (isOptional ? "true" : "false") << ", " << (isOptional ? (*dmli)->tag() : 0) << ']';
     }
     if (members.size() > 1)
     {
@@ -1038,7 +1040,7 @@ Slice::Ruby::CodeVisitor::writeConstructorParams(const DataMemberList& members)
         {
             writeConstantValue(member->type(), member->defaultValueType(), *member->defaultValue());
         }
-        else if (member->optional())
+        else if (member->isOptional())
         {
             _out << "Ice::Unset";
         }