         return false
     }
     var isStructural : Bool {
-        guard let expression = grammarRule?.expression else {
-            return false
-        }
-        
-        if isDiscarded {
-            return false
-        }
-        
-        let fields = SwiftStructure.generate(expression: expression)
-        if fields.count == 0 {
-            return false
-        }
-        
-        return true
+        return SwiftStructure.isStructural(identifier: self)
     }
 }
 

        return []
    }
    
    private static func generate(element:STLRScope.Element)->Field?{
        guard element.isStructural else {
            return nil

            } else {
                field = Field(name: token, type: token.typeName)
            }
        case .group(let expression, let modifier, let lookahead, let annotations):
            if lookahead {
                return nil
            }
            if annotations.asRuleAnnotations[.void] == .set || annotations.asRuleAnnotations[.transient] == .set {
                return nil
            }
            if modifier == .transient || modifier == .void || modifier == .not{
                return nil
            }

            let fields = generate(expression: expression)
            
            return fields.first
        }
        
        if let field = field {
