anchor.diff:                  if onlyOnceWarnings.Add(msg) then
                       addWarning com [] range msg
   
  -            member _.TryAddImportPath(path) =
  -                importPaths.Add(path)
  -
  -            member _.GetImportName(ctx, selector, path, r) =
  +            member _.TryAddImport(modName) =
  +                importModules.Add(modName)
  +
  +            member self.GetImportName(ctx, selector, path, r) =
                   let importPath, importName =
                       match path.Split('|') with
                       | [| path; namesp |] ->
  
positive.code:             Fable.Path.Combine(currentDir, path)
              |> Fable.Path.normalizeFullPath
  
      let transformImports com ctx (imports: string seq): Rust.Item list =
          imports
          |> List.ofSeq
          |> List.sort
          |> List.collect (fun (importPath: string) ->
              let fullPath = getImportFullPath com importPath
              let modName = System.String.Format("import_{0:x}", hash fullPath)
              let attrs = [mkEqAttr "path" ("\"" + importPath  + "\"")]
              let modItem = mkUnloadedModItem attrs modName |> mkNonPublicItem
              let useItem = mkGlobUseItem [] [modName] |> mkNonPublicItem
  
negative.code:                         path, (namesp +  "::" + selector)
                      | _ ->
                          path, selector
  
                  let modName =
                      match imports.TryGetValue(importPath) with
                      | true, modName -> modName
                      | false, _ ->
                          let fullPath = Util.getImportFullPath self importPath
                          let modName = System.String.Format("import_{0:x}", hash fullPath)
                          imports.Add(importPath, modName)
                          modName
  
                  // $"crate::{modName}::{importName}"
                  $"{importName}"
  
              member _.GetAllImports() = imports |> Seq.map (fun pair -> pair.Key, pair.Value)
              member self.TransformAsExpr(ctx, e) = Util.transformAsExpr self ctx e
          //     member self.TransformAsStatements(ctx, ret, e) = transformAsStatements self ctx ret e
          //     member self.TransformFunction(ctx, name, args, body) = transformFunction self ctx name args body
  