diff --git a/src/compiler/ast.rs b/src/compiler/ast.rs
index dfd1ac2..cac2574 100644
--- a/src/compiler/ast.rs
+++ b/src/compiler/ast.rs
@@ -406,6 +406,7 @@ fn traverse_node_static(scope: &Scope, assign: Option<String>, node: &Dict) -> I
     let emit = node["emit"].borrow();
     let emit = emit.object::<Str>().unwrap().as_str();
 
+    /*
     // Special case: Put a generic with an assignment name into its own parselet
     if emit == "value_generic" && assign.is_some() {
         // Handle anything else as an implicit parselet in its own scope
@@ -425,7 +426,9 @@ fn traverse_node_static(scope: &Scope, assign: Option<String>, node: &Dict) -> I
         );
 
         ImlValue::from(implicit_parselet)
-    } else if emit.starts_with("value_") {
+    } else
+    */
+    if emit.starts_with("value_") {
         traverse_node_value(scope, node, assign).try_resolve(scope)
     } else {
         // Handle anything else as an implicit parselet in its own scope
diff --git a/src/compiler/iml/imlvalue.rs b/src/compiler/iml/imlvalue.rs
index 3fe2a71..69fc8f2 100644
--- a/src/compiler/iml/imlvalue.rs
+++ b/src/compiler/iml/imlvalue.rs
@@ -119,7 +119,6 @@ impl ImlValue {
             Self::Shared(rc) => {
                 match Rc::try_unwrap(rc) {
                     Ok(value) => {
-                        // println!("UNCHAIN {:?}", value);
                         value.into_inner().resolve(scope)
                     }
                     Err(rc) => {
@@ -132,28 +131,6 @@ impl ImlValue {
                             *value = resolved.clone();
                             resolved
                         }
-
-                        /*
-                        let mut later = false;
-
-                        match rc.try_borrow_mut() {
-                            Ok(mut value) => {
-                                let resolved = value.clone().resolve(scope, i + 1);
-                                if !matches!(resolved, Self::Name { .. } | Self::Instance { .. }) {
-                                    *value = resolved.clone();
-                                    return resolved;
-                                }
-                            }
-                            Err(_) => later = true,
-                        }
-
-                        if later {
-                            ImlValue::Shared(rc).later(scope)
-                        }
-                        else {
-                            ImlValue::Shared(rc)
-                        }
-                        */
                     }
                 }
             }
@@ -181,11 +158,11 @@ impl ImlValue {
                         // Take arguments by sequence first
                         let arg = if !args.is_empty() {
                             let arg = args.remove(0);
-                            (arg.0, Some(arg.1.try_resolve(scope)))
+                            (arg.0, Some(arg.1.resolve(scope)))
                         }
                         // Otherwise, take named arguments
                         else if let Some(narg) = nargs.shift_remove(name) {
-                            (narg.0, Some(narg.1.try_resolve(scope)))
+                            (narg.0, Some(narg.1.resolve(scope)))
                         }
                         // Otherwise, use default
                         else {
@@ -306,7 +283,7 @@ impl ImlValue {
                     true
                 }
             }
-            Self::Instance { target, .. } => true,
+            Self::Instance { .. } => true,
             _ => false,
         }
     }
diff --git a/tests/parselet_generic_selfref.tok b/tests/parselet_generic_selfref.tok
index f09f3fb..dbd16f6 100644
--- a/tests/parselet_generic_selfref.tok
+++ b/tests/parselet_generic_selfref.tok
@@ -3,8 +3,8 @@ Assignment : @<Expression, Assignment: Assignment, ext: void> {
     Expression  ast("value")
 }
 
-HoldAssignment : Assignment<Int, HoldAssignment>  # endless recursion!
-# HoldAssignment : Assignment<Int, HoldAssignment> Empty  # works!
+# HoldAssignment : Assignment<Int, HoldAssignment>  # fails with endless recursion!
+HoldAssignment : Assignment<Int, HoldAssignment> Empty  # workaround!
 
 # ast_print(Assignment<Int>)
 ast_print(HoldAssignment)