anchor.diff:                  if not(List.isEmpty generics) then
                       Expression.list(generics)
               ]
  -        let genericTypeInfo name genArgs =
  +        let genericTypeAnnotation name genArgs =
               let resolved, stmts = resolveGenerics genArgs
               typingHint com ctx name resolved, stmts
   
           match t with
           | Fable.Measure _
  -        | Fable.Any -> typingModuleTypeHint "Any" [||]
  +        | Fable.Any -> typingModuleTypeHint "Any" []
           | Fable.GenericParam(name,_) ->
               com.GetImportExpr(ctx, "typing", "TypeVar") |> ignore
               let name = Helpers.clean name
               com.AddTypeVar name
  -            match Map.tryFind name genMap with
  -            | Some t -> t, []
  -            | None -> Expression.name(name), []
  +            Expression.name(name), []
           | Fable.Unit    -> Expression.none, []
           | Fable.Boolean -> Expression.name "bool", []
           | Fable.Char    -> Expression.name "str", []
  
positive.code:             |> libReflectionCall com ctx None "enum", []
          | Fable.Number(kind,_) -> numberInfo kind, []
          | Fable.LambdaType(argType, returnType) ->
              genericTypeInfo "Callable" [| argType; returnType |]
          | Fable.Option(genArg,_)   -> genericTypeInfo "Optional" [| genArg |]
          | Fable.Tuple(genArgs,_)   -> genericTypeInfo "Tuple" (List.toArray genArgs)
          | Fable.Array genArg ->
              match genArg with
              | Fable.Type.Number(UInt8, _) ->
                  typingModuleTypeHint "ByteString" [||]
              | Fable.Type.Number(Int8, _)
              | Fable.Type.Number(Int16, _)
              | Fable.Type.Number(UInt16, _)
              | Fable.Type.Number(Int32, _)
              | Fable.Type.Number(UInt32, _)
              | Fable.Type.Number(Float32, _)
              | Fable.Type.Number(Float64, _) ->
                  pythonModuleTypeHint "array" "array" [||]
              | _ ->
                  typingModuleTypeHint "List" [| genArg |]
          | Fable.List genArg     -> fableModuleTypeInfo "list" "FSharpList" [| genArg |]
          | _ ->
              typingModuleTypeHint "Any" [||]
  (*
          | Fable.DelegateType(argTypes, returnType) ->
              genericTypeInfo "delegate" ([|yield! argTypes; yield returnType|])
          | Fable.Regex           -> nonGenericTypeInfo Types.regex, []
          | Fable.MetaType        -> nonGenericTypeInfo Types.type_, []
          | Fable.AnonymousRecordType(fieldNames, genArgs) ->
              let genArgs, stmts = resolveGenerics (List.toArray genArgs)
              List.zip (List.ofArray fieldNames) genArgs
              |> List.map (fun (k, t) -> Expression.list[ Expression.constant(k); t ])
              |> libReflectionCall com ctx None "anonRecord", stmts
          | Fable.DeclaredType(entRef, generics) ->
              let fullName = entRef.FullName
              match fullName, generics with
              | Replacements.BuiltinEntity kind ->
                  match kind with
                  | Replacements.BclGuid
                  | Replacements.BclTimeSpan
                  | Replacements.BclDateTime
  
negative.code:                 let args' =
                      args
                      |> List.map (fun id ->
                          let ta, _ = typeAnnotation com ctx id.Type
                          Arg.arg(ident com ctx id, annotation=ta))
                  args', defaults, body
  
          let arguments =
  