Correctly reference global JSON/YAML modules (#16161)

Author: Sija

spec/std/json/serializable_spec.cr

@@ -577,7 +577,24 @@ class JSONInitializeOpts
   end
 end
 
-describe "JSON mapping" do
+record Namespaced::JSON::Wrapper, name : String, options : Hash(String, ::JSON::Any::Type)? = nil do
+  include ::JSON::Serializable
+end
+
+describe "JSON::Serializable" do
+  it "works with classes within `JSON` namespace" do
+    Namespaced::JSON::Wrapper
+      .from_json(<<-JSON)
+        {
+          "name": "foo",
+          "options": {
+            "foo": true
+          }
+        }
+        JSON
+      .to_json
+  end
+
   it "works with record" do
     JSONAttrPoint.new(1, 2).to_json.should eq "{\"x\":1,\"y\":2}"
     JSONAttrPoint.from_json(%({"x": 1, "y": 2})).should eq JSONAttrPoint.new(1, 2)

spec/std/yaml/serializable_spec.cr

@@ -477,7 +477,21 @@ class YAMLInitializeOpts
   end
 end
 
+record Namespaced::YAML::Wrapper, name : String, options : Hash(String, ::YAML::Any::Type)? = nil do
+  include ::YAML::Serializable
+end
+
 describe "YAML::Serializable" do
+  it "works with classes within `YAML` namespace" do
+    Namespaced::YAML::Wrapper
+      .from_yaml(<<-YAML)
+          name: foo
+          options:
+            foo: true
+        YAML
+      .to_yaml
+  end
+
   it "works with record" do
     YAMLAttrPoint.new(1, 2).to_yaml.should eq "---\nx: 1\ny: 2\n"
     YAMLAttrPoint.from_yaml("---\nx: 1\ny: 2\n").should eq YAMLAttrPoint.new(1, 2)

src/json/serialization.cr

@@ -207,7 +207,7 @@ module JSON
             # `%var`'s type must be exact to avoid type inference issues with
             # recursively defined serializable types
             {% for name, value in properties %}
-              %var{name} = uninitialized ::Union({{value[:type]}})
+              %var{name} = uninitialized ::Union(typeof(@{{ name }}))
               %found{name} = false
             {% end %}
 
@@ -239,7 +239,7 @@ module JSON
                         {% if value[:converter] %}
                           {{value[:converter]}}.from_json(pull)
                         {% else %}
-                          ::Union({{value[:type]}}).new(pull)
+                          ::Union(typeof(@{{ name }})).new(pull)
                         {% end %}
                       end
                     %found{name} = true
@@ -365,12 +365,12 @@ module JSON
     end
 
     module Unmapped
-      @[JSON::Field(ignore: true)]
-      property json_unmapped = Hash(String, JSON::Any).new
+      @[::JSON::Field(ignore: true)]
+      property json_unmapped = Hash(String, ::JSON::Any).new
 
       protected def on_unknown_json_attribute(pull, key, key_location)
         json_unmapped[key] = begin
-          JSON::Any.new(pull)
+          ::JSON::Any.new(pull)
         rescue exc : ::JSON::ParseException
           raise ::JSON::SerializableError.new(exc.message, self.class.to_s, key, *key_location, exc)
         end

src/yaml/serialization.cr

@@ -188,7 +188,7 @@ module YAML
         end
       end
 
-      def initialize(*, __context_for_yaml_serializable ctx : YAML::ParseContext, __node_for_yaml_serializable node : ::YAML::Nodes::Node)
+      def initialize(*, __context_for_yaml_serializable ctx : ::YAML::ParseContext, __node_for_yaml_serializable node : ::YAML::Nodes::Node)
         {% verbatim do %}
           {% begin %}
             {% properties = {} of Nil => Nil %}
@@ -212,14 +212,14 @@ module YAML
             # `%var`'s type must be exact to avoid type inference issues with
             # recursively defined serializable types
             {% for name, value in properties %}
-              %var{name} = uninitialized ::Union({{value[:type]}})
+              %var{name} = uninitialized ::Union(typeof(@{{ name }}))
               %found{name} = false
             {% end %}
 
             case node
-            when YAML::Nodes::Mapping
-              YAML::Schema::Core.each(node) do |key_node, value_node|
-                unless key_node.is_a?(YAML::Nodes::Scalar)
+            when ::YAML::Nodes::Mapping
+              ::YAML::Schema::Core.each(node) do |key_node, value_node|
+                unless key_node.is_a?(::YAML::Nodes::Scalar)
                   key_node.raise "Expected scalar as key for mapping"
                 end
 
@@ -230,7 +230,7 @@ module YAML
                   when {{value[:key]}}
                     begin
                       {% if value[:has_default] || value[:nilable] %}
-                        if YAML::Schema::Core.parse_null?(value_node)
+                        if ::YAML::Schema::Core.parse_null?(value_node)
                           {% if value[:nilable] %}
                             %var{name} = nil
                             %found{name} = true
@@ -243,7 +243,7 @@ module YAML
                         {% if value[:converter] %}
                           {{value[:converter]}}.from_yaml(ctx, value_node)
                         {% else %}
-                          ::Union({{value[:type]}}).new(ctx, value_node)
+                          ::Union(typeof(@{{ name }})).new(ctx, value_node)
                         {% end %}
                       %found{name} = true
                     end
@@ -252,7 +252,7 @@ module YAML
                   on_unknown_yaml_attribute(ctx, key, key_node, value_node)
                 end
               end
-            when YAML::Nodes::Scalar
+            when ::YAML::Nodes::Scalar
               if node.value.empty? && node.style.plain? && !node.tag
                 # We consider an empty scalar as an empty mapping
               else
@@ -353,11 +353,11 @@ module YAML
     end
 
     module Unmapped
-      @[YAML::Field(ignore: true)]
-      property yaml_unmapped = Hash(String, YAML::Any).new
+      @[::YAML::Field(ignore: true)]
+      property yaml_unmapped = Hash(String, ::YAML::Any).new
 
       protected def on_unknown_yaml_attribute(ctx, key, key_node, value_node)
-        yaml_unmapped[key] = YAML::Any.new(ctx, value_node)
+        yaml_unmapped[key] = ::YAML::Any.new(ctx, value_node)
       end
 
       protected def on_to_yaml(yaml)