anchor.diff:  
           let numberInfo kind =
               Expression.name (getNumberKindName kind)
  -        let nonGenericTypeInfo fullname =
  -            [ Expression.constant(fullname) ]
  -            |> libReflectionCall com ctx None "class"
  -        let genericEntity (fullname: string) (generics: Expression list) =
  -            libReflectionCall com ctx None "class" [
  -                Expression.constant(fullname)
  -                if not(List.isEmpty generics) then
  -                    Expression.list(generics)
  -            ]
           let genericTypeAnnotation name genArgs =
               let resolved, stmts = resolveGenerics genArgs None
               typingHint com ctx name resolved, stmts
  
positive.code:         Statement.expr(callSuper args)
  
      let makeClassConstructor (args: Arguments) (isOptional: bool) body =
          // printfn "makeClassConstructor: %A" body
          let name = Identifier("__init__")
          let self = Arg.arg("self")
          let args =
              match args.Args with
              | [ _unit ] when isOptional ->
                  { args with Args = self::args.Args; Defaults=[ Expression.none ] }
              | _ ->
                  { args with Args = self::args.Args }
  
          match body with
          | []
          | [ Statement.Pass ] -> []
          | _ -> [ Statement.functionDef(name, args, body = body, returns=Expression.none) ]
  
      let callFunction r funcExpr (args: Expression list) (kw: Keyword list) =
          Expression.call(funcExpr, args, kw=kw, ?loc=r)
  
negative.code:         else
              Expression.subscript(name, Expression.tuple typeParamInst)
  
      let makeGenericTypeAnnotation' (com: IPythonCompiler) ctx (id: string) (genArgs: string list) (repeatedGenerics: Set<string> option) =
          pythonModuleAnnotation com ctx "__future__" "annotations" [] |> ignore
  
          let name = Expression.name id
          if genArgs.IsEmpty then
              name
          else
              let genArgs =
                  match repeatedGenerics with
                  | Some generics ->
                      let genArgs = genArgs |> Set.ofList |> Set.intersect generics |> Set.toList
                      if genArgs.IsEmpty then [ typingHint com ctx "Any" [] ]
                      else genArgs |> List.map (fun name -> com.AddTypeVar(ctx, name))
                  | _ ->
                      genArgs |> List.map (fun name -> com.AddTypeVar(ctx, name))
              Expression.subscript(name, Expression.tuple genArgs)
  
      let typeAnnotation (com: IPythonCompiler) ctx (repeatedGenerics: Set<string> option) t : Expression * Statement list =
          let getNumberKindName kind =
              match kind with
  