Get the class variables of some Type in a macro

spec/compiler/macro/macro_methods_spec.cr

@@ -1,5 +1,15 @@
 require "../../spec_helper"
 
+private def declare_class_var(container : ClassVarContainer, name, var_type : Type, annotations = nil)
+  var = MetaTypeVar.new(name)
+  var.owner = container
+  var.type = var_type
+  var.annotations = annotations
+  var.bind_to var
+  var.freeze_type = var_type
+  container.class_vars[name] = var
+end
+
 module Crystal
   describe "macro methods" do
     describe "node methods" do
@@ -1094,6 +1104,71 @@ module Crystal
         end
       end
 
+      it "executes class vars" do
+        assert_macro("x", "{{x.class_vars.map &.name}}", %([class_var])) do |program|
+          klass = NonGenericClassType.new(program, program, "SomeType", program.reference)
+          declare_class_var(klass, "@@class_var", program.string)
+          [TypeNode.new(klass)] of ASTNode
+        end
+      end
+
+      it "executes class vars (with inheritance)" do
+        assert_macro("x", "{{x.class_vars.map &.name}}", %([child_class_var, base_class_var, mod_class_var])) do |program|
+          base_class = NonGenericClassType.new(program, program, "BaseType", program.reference)
+          declare_class_var(base_class, "@@base_class_var", program.string)
+          mod = NonGenericModuleType.new(program, program, "SomeModule")
+          declare_class_var(mod, "@@mod_class_var", program.string)
+          base_class.include mod
+          child_class = NonGenericClassType.new(program, program, "ChildType", base_class)
+          declare_class_var(child_class, "@@child_class_var", program.string)
+          [TypeNode.new(child_class)] of ASTNode
+        end
+      end
+
+      it "executes instance_vars on metaclass" do
+        assert_macro("x", "{{x.class.instance_vars.map &.stringify}}", %([])) do |program|
+          klass = NonGenericClassType.new(program, program, "SomeType", program.reference)
+          klass.declare_instance_var("@var", program.string)
+          [TypeNode.new(klass)] of ASTNode
+        end
+      end
+
+      it "executes class_vars on metaclass" do
+        assert_macro("x", "{{x.class.class_vars.map &.stringify}}", %([])) do |program|
+          klass = NonGenericClassType.new(program, program, "SomeType", program.reference)
+          declare_class_var(klass, "@@class_var", program.string)
+          [TypeNode.new(klass)] of ASTNode
+        end
+      end
+
+      it "executes instance_vars on symbol literal" do
+        assert_macro("x", "{{x.instance_vars.map &.stringify}}", %([])) do |program|
+          [TypeNode.new(SymbolLiteralType.new(program, "foo".symbol))] of ASTNode
+        end
+      end
+
+      it "executes class_vars on symbol literal" do
+        assert_macro("x", "{{x.class_vars.map &.stringify}}", %([])) do |program|
+          [TypeNode.new(SymbolLiteralType.new(program, "foo".symbol))] of ASTNode
+        end
+      end
+
+      it "executes methods" do
+        assert_macro("x", "{{x.methods.map &.name}}", %([foo])) do |program|
+          klass = NonGenericClassType.new(program, program, "SomeType", program.reference)
+          a_def = Def.new "foo"
+          klass.add_def a_def
+          [TypeNode.new(klass)] of ASTNode
+        end
+      end
+
+      it "executes class methods" do
+        assert_macro("x", "{{x.class.methods.map &.name}}", %([allocate])) do |program|
+          klass = NonGenericClassType.new(program, program, "SomeType", program.reference)
+          [TypeNode.new(klass)] of ASTNode
+        end
+      end
+
       it "executes ancestors" do
         assert_macro("x", "{{x.ancestors}}", %([SomeModule, Reference, Object])) do |program|
           mod = NonGenericModuleType.new(program, program, "SomeModule")

src/compiler/crystal/macros.cr

@@ -1730,6 +1730,10 @@ module Crystal::Macros
     def instance_vars : ArrayLiteral(MetaVar)
     end
 
+    # Returns the class variables of this type.
+    def class_vars : ArrayLiteral(MetaVar)
+    end
+
     # Returns all ancestors of this type.
     def ancestors : ArrayLiteral(TypeNode)
     end

src/compiler/crystal/macros/methods.cr

@@ -1514,6 +1514,8 @@ module Crystal
         interpret_argless_method(method, args) { TypeNode.type_vars(type) }
       when "instance_vars"
         interpret_argless_method(method, args) { TypeNode.instance_vars(type) }
+      when "class_vars"
+        interpret_argless_method(method, args) { TypeNode.class_vars(type) }
       when "ancestors"
         interpret_argless_method(method, args) { TypeNode.ancestors(type) }
       when "superclass"
@@ -1704,6 +1706,19 @@ module Crystal
       end
     end
 
+    def self.class_vars(type)
+      if type.is_a?(ClassVarContainer)
+        ArrayLiteral.map(type.all_class_vars) do |name, ivar|
+          meta_var = MetaMacroVar.new(name[2..-1], ivar.type)
+          meta_var.var = ivar
+          meta_var.default_value = ivar.initializer.try(&.node)
+          meta_var
+        end
+      else
+        empty_no_return_array
+      end
+    end
+
     def self.ancestors(type)
       ancestors = type.ancestors
       if ancestors.empty?

src/compiler/crystal/types.cr

@@ -549,6 +549,10 @@ module Crystal
       raise "BUG: #{self} doesn't implement instance_vars"
     end
 
+    def class_vars
+      raise "BUG: #{self} doesn't implement class_vars"
+    end
+
     def all_instance_vars
       if superclass = self.superclass
         superclass.all_instance_vars.merge(instance_vars)
@@ -557,6 +561,15 @@ module Crystal
       end
     end
 
+    def all_class_vars
+      all_class_vars = {} of String => MetaTypeVar
+      all_class_vars.merge!(class_vars)
+      parents.try &.each do |parent|
+        all_class_vars.merge!(parent.all_class_vars)
+      end
+      all_class_vars
+    end
+
     def index_of_instance_var(name)
       if superclass = self.superclass
         index = superclass.index_of_instance_var(name)
@@ -3234,6 +3247,13 @@ module Crystal
       nil
     end
 
+    def all_class_vars
+      all_class_vars = {} of String => MetaTypeVar
+      @class_vars.try { |v| all_class_vars.merge!(v) }
+      all_class_vars.merge!(base_type.all_class_vars)
+      all_class_vars
+    end
+
     def replace_type_parameters(instance)
       base_type.replace_type_parameters(instance).virtual_type
     end