zeroc-ice 3.8.0 → 3.8.2

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.
@@ -95,8 +95,21 @@ Slice::validateMetadata(const UnitPtr& p, string_view prefix, map<string, Metada
              typeid(DataMember)},
         .acceptedArgumentKind = MetadataArgumentKind::OptionalTextArgument,
     };
-    knownMetadata.emplace("deprecate", deprecatedInfo); // Kept as an alias for 'deprecated'.
-    knownMetadata.emplace("deprecated", std::move(deprecatedInfo));
+    knownMetadata.emplace("deprecated", deprecatedInfo);
+
+    // We keep support for 'deprecate' as an alias for 'deprecated', but disallow using both on the same element.
+    deprecatedInfo.extraValidation = [](const MetadataPtr&, const SyntaxTreeBasePtr& q) -> optional<string>
+    {
+        if (auto contained = dynamic_pointer_cast<Contained>(q))
+        {
+            if (contained->hasMetadata("deprecated"))
+            {
+                return "you cannot apply both 'deprecated' and 'deprecate' metadata to the same element";
+            }
+        }
+        return nullopt;
+    },
+    knownMetadata.emplace("deprecate", std::move(deprecatedInfo));
 
     // "format"
     MetadataInfo formatInfo = {
@@ -113,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)},
@@ -124,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)
@@ -135,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