                 ;; has true or false)
                 (let [plant-class (if (= :plant-fn-symbol type)
                                     (if (= name 'this) pclass name)
-                                    (get-in ir [pclass :fields :field :initial :pclass]))
+                                    (get-in ir [pclass :fields field :initial :pclass]))
                       plant-fn-primitive?
                       (get-in ir [plant-class :methods method :primitive])
+                      _ (println "plant-class" plant-class "plant-fn-primitive?" plant-fn-primitive?)
                       [plant-class non-primitive?]
                       (if (nil? plant-fn-primitive?)  ;;TODO - Should error here
                         [::unknown false]

                             :arguments args
                             :temporal-constraints temporal-constraints
                             :irks irks-i})
                      nt (if make-htn-method?
                           (htn-nonprimitive-task
                             {:pclass pclass
                              :name mname
                              :arguments margs
                              :irks irks-i}))
                      st (if make-htn-method? [task])]
                  ;; (println "  PLANT-FN-SYMBOL TASK" task)
                  ;; (println "  PLANT-FN-SYMBOL SUBTASKS" st)
                  (when make-htn-method? ;; make htn-method
                    (let [hm (htn-method {:pclass pclass
                                          :name mname
                                          :display-name display-name
                                          :nonprimitive-task nt
                                          :subtasks st
                                          :irks irks-i})]
                      ;; (println "HTN-METHOD" (with-out-str (pprint hm)))
                      ;; (pprint-htn-methods)
                      hm))
                  task)

                      ;; functions, but the HEM logic does not support it.
                      ;; make-htn-method? (or (symbol? mname)
                      ;;                    (nil? plant-fn-primitive?))
                      ;; NOTE: We will make an htn-method, if (not plant-fn-primitive?)
                      ;;make-htn-method? (symbol? mname)
                      ;; DEBUG
                      ;; _ (println "  make-htn-method?" make-htn-method?
                      ;;     "plant-class" plant-class
