anchor.diff:              let all =
                   let semTypes =
                       Introspection.GetAllTypesWithAttribute<RuleAttribute>()
  -                    |> Seq.collect (fun struct (t,_) -> t.GetMethods(BindingFlags.Static ||| BindingFlags.Instance ||| BindingFlags.NonPublic ||| BindingFlags.Public))
  +                    |> Seq.collect (fun struct (t,_) -> t.GetMethods(BindingFlags.Static ||| BindingFlags.Instance ||| BindingFlags.NonPublic ||| BindingFlags.Public ||| BindingFlags.DeclaredOnly))
                   let semMeths = 
                       Introspection.GetAllMethodsWithAttribute<RuleAttribute>()
                       |> Seq.map (fun struct (m,_) -> m)
  +
                   Seq.append semTypes semMeths 
  -                |> Seq.filter (fun m -> not m.DeclaringType.ContainsGenericParameters)
  -                |> Seq.filter (fun m -> not (isNull (m.DeclaringType.GetConstructor(BindingFlags.NonPublic ||| BindingFlags.Public ||| BindingFlags.Instance, Type.DefaultBinder, [||], null))))
  +                |> Seq.filter (fun m -> 
  +                    let decl = m.DeclaringType
  +                    let ps = m.GetParameters()
  +
  +                    let generated = m.GetCustomAttribute<System.Runtime.CompilerServices.CompilerGeneratedAttribute>()
  +
  +                    if not (isNull generated) then
  +                        false
  +                    elif decl.ContainsGenericParameters then
  +                        Log.warn "unexpected generic rule-type: %A" decl
  +                        false
  +                    elif ps.Length <> 2 || (ps.Length = 2 && ps.[1].ParameterType <> typeof<Scope>) then
  +                        Log.warn "unexpected rule: %A" m
  +                        false
  +                    elif not m.IsStatic then
  +                        let ctor = decl.GetConstructor(BindingFlags.NonPublic ||| BindingFlags.Public ||| BindingFlags.Instance, Type.DefaultBinder, [||], null)
  +                        if isNull ctor then
  +                            Log.warn "cannot construct rule type: %A" decl
  +                            false
  +                        else
  +                            true
  +                    else
  +                        true
  +                )
                   |> Seq.toArray
   
               let synRules : Dictionary<string, MethodInfo[]> =
  
positive.code:         Ag.runinh this name
          
      [<Extension>]
      static member GetInherted(this : Ag.Scope, name : string) =
          match Ag.runinh this name with
          | Some v -> v
          | None -> failwithf "[Ag] could not get inh attribute %s in scope %A" name this
          
      [<Extension>]
      static member TryGetSynthesized<'a>(node : obj, name : string, scope : Ag.Scope) =
          Ag.syn node scope name typeof<'a>
          
      [<Extension>]
      static member GetSynthesized<'a>(node : obj, name : string, scope : Ag.Scope) =
          match Ag.syn node scope name typeof<'a> with
          | Some v -> v
          | None -> failwithf "[Ag] could not get syn attribute %s on node %A" name node
  
  //[<AutoOpen>]
  //module AgOperators =    
  
negative.code: 
          let table = lazy (RuleTable())
  
      let hasSynRule (nodeType : Type) (expected : Type) (name : string) =
          match table.Value.TryGetSynRule(name, nodeType, expected) with
          | Some _ -> true
          | None -> false
  
      let rec internal runinh (scope : Scope) (name : string) =
          match scope.TryGetInheritedCache(name) with
          | Some v -> 
  