Replace macros with functions in TypeInfoVisitor

Author: Josh Price

lib/graphql/lang/ast/type_info_visitor.ex

@@ -19,22 +19,18 @@ defmodule GraphQL.Lang.AST.TypeInfoVisitor do
 
   defimpl Visitor do
 
-    defmacrop stack_push(stack_name, value) do
-      quote do
-        old_type_info = var!(accumulator)[:type_info]
-        new_type_info = %TypeInfo{old_type_info |
-          unquote(stack_name) => Stack.push(old_type_info.unquote(stack_name), unquote(value))}
-        put_in(var!(accumulator)[:type_info], new_type_info)
-      end
+    def stack_push(accumulator, stack_name, value) do
+      old_type_info = accumulator[:type_info]
+      stack = Stack.push(Map.get(old_type_info, stack_name), value)
+      new_type_info = Map.merge(old_type_info, %{stack_name => stack})
+      put_in(accumulator[:type_info], new_type_info)
     end
 
-    defmacrop stack_pop(stack_name) do
-      quote do
-        old_type_info = var!(accumulator)[:type_info]
-        new_type_info = %TypeInfo{old_type_info |
-          unquote(stack_name) => Stack.pop(old_type_info.unquote(stack_name))}
-        put_in(var!(accumulator)[:type_info], new_type_info)
-      end
+    def stack_pop(accumulator, stack_name) do
+      old_type_info = accumulator[:type_info]
+      stack = Stack.pop(Map.get(old_type_info, stack_name))
+      new_type_info = Map.merge(old_type_info, %{stack_name => stack})
+      put_in(accumulator[:type_info], new_type_info)
     end
 
     def set_directive(accumulator, directive) do
@@ -57,9 +53,9 @@ defmodule GraphQL.Lang.AST.TypeInfoVisitor do
           type = TypeInfo.type(accumulator[:type_info])
           named_type = TypeInfo.named_type(type)
           if Type.is_composite_type?(named_type) do
-            stack_push(:parent_type_stack, named_type)
+            stack_push(accumulator, :parent_type_stack, named_type)
           else
-            stack_push(:parent_type_stack, nil)
+            stack_push(accumulator, :parent_type_stack, nil)
           end
         :Field ->
           parent_type = TypeInfo.parent_type(accumulator[:type_info])
@@ -70,11 +66,11 @@ defmodule GraphQL.Lang.AST.TypeInfoVisitor do
               node
             )
             field_def_type = if field_def, do: field_def.type, else: nil
-            accumulator = stack_push(:field_def_stack, field_def)
-            stack_push(:type_stack, field_def_type)
+            accumulator = stack_push(accumulator, :field_def_stack, field_def)
+            stack_push(accumulator, :type_stack, field_def_type)
           else
-            accumulator = stack_push(:field_def_stack, nil)
-            stack_push(:type_stack, nil)
+            accumulator = stack_push(accumulator, :field_def_stack, nil)
+            stack_push(accumulator, :type_stack, nil)
           end
         :Directive ->
           # add this once we add directive validations
@@ -92,17 +88,17 @@ defmodule GraphQL.Lang.AST.TypeInfoVisitor do
             :mutation -> accumulator[:type_info].schema.mutation
             _ -> raise "node operation #{node.operation} not handled"
           end
-          stack_push(:type_stack, type)
+          stack_push(accumulator, :type_stack, type)
         kind when kind in [:InlineFragment, :FragmentDefinition] ->
           output_type = if Map.has_key?(node, :typeCondition) do
             Schema.type_from_ast(node.typeCondition, accumulator[:type_info].schema)
           else
             TypeInfo.type(accumulator[:type_info])
           end
-          stack_push(:type_stack, output_type)
+          stack_push(accumulator, :type_stack, output_type)
         :VariableDefinition ->
           input_type = Schema.type_from_ast(node.type, accumulator[:type_info].schema)
-          stack_push(:input_type_stack, input_type)
+          stack_push(accumulator, :input_type_stack, input_type)
         :Argument ->
           field_or_directive = TypeInfo.directive(accumulator[:type_info]) ||
                                TypeInfo.field_def(accumulator[:type_info])
@@ -112,18 +108,18 @@ defmodule GraphQL.Lang.AST.TypeInfoVisitor do
               fn(arg) -> arg == node.name.value end
             )
             accumulator = set_argument(accumulator, arg_def)
-            stack_push(:input_type_stack, (if arg_def && Map.has_key?(arg_def, :type), do: arg_def.type, else: nil))
+            stack_push(accumulator, :input_type_stack, (if arg_def && Map.has_key?(arg_def, :type), do: arg_def.type, else: nil))
           else
             accumulator = set_argument(accumulator, nil)
-            stack_push(:input_type_stack, nil)
+            stack_push(accumulator, :input_type_stack, nil)
           end
         :List ->
           input_type = TypeInfo.input_type(accumulator[:type_info])
           list_type = TypeInfo.named_type(input_type)
           if %Type.List{} === list_type  do
-            stack_push(:input_type_stack, list_type.ofType)
+            stack_push(accumulator, :input_type_stack, list_type.ofType)
           else
-            stack_push(:input_type_stack, nil)
+            stack_push(accumulator, :input_type_stack, nil)
           end
         :ObjectField ->
           input_type = TypeInfo.input_type(accumulator[:type_info])
@@ -135,9 +131,9 @@ defmodule GraphQL.Lang.AST.TypeInfoVisitor do
               node
             )
             field_type = if input_field, do: input_field.type, else: nil
-            stack_push(:input_type_stack, field_type)
+            stack_push(accumulator, :input_type_stack, field_type)
           else
-            stack_push(:input_type_stack, nil)
+            stack_push(accumulator, :input_type_stack, nil)
           end
         _ ->
           accumulator
@@ -148,18 +144,18 @@ defmodule GraphQL.Lang.AST.TypeInfoVisitor do
     def leave(_visitor, node, accumulator) do
       case node.kind do
         :SelectionSet ->
-          stack_pop(:parent_type_stack)
+          stack_pop(accumulator, :parent_type_stack)
         :Field ->
-          accumulator = stack_pop(:field_def_stack)
-          stack_pop(:type_stack)
+          accumulator = stack_pop(accumulator, :field_def_stack)
+          stack_pop(accumulator, :type_stack)
         :Directive ->
           set_directive(accumulator, nil)
         kind when kind in [:OperationDefinition, :InlineFragment, :FragmentDefinition] ->
-          stack_pop(:type_stack)
+          stack_pop(accumulator, :type_stack)
         :Argument ->
           set_argument(accumulator, nil)
         kind when kind in [:List, :ObjectField, :VariableDefinition] ->
-          stack_pop(:input_type_stack)
+          stack_pop(accumulator, :input_type_stack)
         _ ->
           accumulator
       end