anchor.diff:                  let args' =
                       args
                       |> List.map (fun id ->
  -                        let annotation, _ = transformTypeHint com ctx None Map.empty id.Type
  -                        Arg.arg(ident com ctx id, annotation=annotation))
  +                        let ta, _ = typeAnnotation com ctx id.Type
  +                        Arg.arg(ident com ctx id, annotation=ta))
                   args', defaults, body
   
           let arguments =
  
positive.code:             | Float32 | Float64 -> "float"
  
          let resolveGenerics generics: Expression list * Statement list =
              generics |> Array.map (transformTypeHint com ctx r genMap) |> List.ofArray |> Helpers.unzipArgs
  
          let fableModuleTypeInfo moduleName memberName genArgs =
              let resolved, stmts = resolveGenerics genArgs
              fableModuleHint com ctx moduleName memberName resolved, stmts
  
          let pythonModuleTypeHint moduleName memberName genArgs =
              let resolved, stmts = resolveGenerics genArgs
              pythonModuleHint com ctx moduleName memberName resolved, stmts
  
          let typingModuleTypeHint name genArgs =
             pythonModuleTypeHint "typing" name genArgs
  
negative.code:                 match im.Name with
                  | Some "*"
                  | Some "default" ->
                      let (Identifier local) = im.LocalIdent.Value
                      if moduleName <> local then
                          Some moduleName, Alias.alias(im.LocalIdent.Value)
                      else
                          None, Alias.alias(im.LocalIdent.Value)
                  | Some name ->
                      let name = Naming.toSnakeCase name
                      Some moduleName, Alias.alias(Identifier(Helpers.clean name), ?asname=im.LocalIdent)
                  | None ->
                      None, Alias.alias(Identifier(moduleName), ?asname=im.LocalIdent))
              |> List.groupBy fst
              |> List.map (fun (a, b) -> a, List.map snd b)
              |> List.sortBy (function
                  // Need to make sure we get imports such as __future__ first
                  | Some moduleName, _ -> moduleName.ToLower()
                  | None, { Name=(name) }::xs -> name.Name
                  | _ -> "")
  
  
          [
              for moduleName, aliases in imports do
                  match moduleName with
  