anchor.diff:                      |> List.map (fun sf -> sf.strictInh)                                // take all strict inh attributes
                       |> Set.intersectMany                                                // take only those needed by all leaf-productions
   
  +            //let strict = Set.empty
   
   
               let kind, retType, dispatcher = createDispatcher strict name sfs
  
positive.code:                     Expr.Call(t, t.Type.GetMethod "WithState", [Expr.PropertyGet(self, self.Type.GetProperty "State")])
  
                  let convert (t : Type) (e : Expr) = Expr.Coerce(e, t)
                  let rec substituteAttributeLookups (self : ref<Option<Var>>) (strictInh : HashSet<string>) (strictSyn : HashSet<string>) (kind : ref<SemanticFunctionKind>) (e : Expr) =
                      match e with
                          | Application(Call(None, mi, [o; Value(:? string as nn, _)]), Value(_)) when mi.Name = "op_Dynamic" ->
                              // syn case
  
                              let traversal =
                                  match !self with
                                      | Some t -> t
                                      | None ->
                                          let t = typedefof<ITraversal<_>>.MakeGenericType [|e.Type|]
                                          let v = Var("traversal", t)
                                          self := Some v
                                          v
  
                              kind := Synthesize
                              strictSyn.Add nn |> ignore
                              if nn = name then
  
negative.code:                 | [] -> failwithf "[Ag] could not create semantic function for '%s'" (methodName m)
                  | sf :: _ -> sf
  
      let mutable traversals : obj[] = null
  
      type Helper =
          static member Lazy (f : unit -> 'a) = Lazy<'a>(f)
  
      [<Demo("Ag")>]
      let generate2() =
  