anchor.diff:      let funcWithArgsRest = resolveType typedefof<WebSharper.JavaScript.FuncWithArgsRest<_,_,_>>
       let optionType = resolveType typedefof<WebSharper.JavaScript.Optional<_>>
   
  -    let wsCore = resolveAsm typeof<WebSharper.InlineAttribute>.Assembly.FullName
  +    let wsCore =
  +        let t = typeof<WebSharper.InlineAttribute>
  +        resolveAsm t.Assembly.FullName t.FullName
   
       member b.SystemAssembly = netstandard
   
  
positive.code:     let assemblies = Dictionary()
      let main = out.MainModule
      let resolvedTypes = Dictionary()
      let tryFindAssembly =
          let domainAssemblies = System.AppDomain.CurrentDomain.GetAssemblies()
          fun (name: string) ->
              let name = name.ToLowerInvariant()
              domainAssemblies
              |> Array.tryFind (fun a -> a.GetName().Name.ToLowerInvariant() = name)
      let netstandard =
          match tryFindAssembly "netstandard" with
          | Some asm -> aR.Resolve(AssemblyNameReference.Parse(asm.FullName))
          | None -> failwith "Not referencing netstandard"
      let addIfExists name asm =
          tryFindAssembly name
          |> Option.iter (fun a -> assemblies.[a.FullName] <- asm)
      do  let m = netstandard.MainModule
          addIfExists "netstandard" netstandard
          addIfExists "System.Private.CoreLib" netstandard
          addIfExists "mscorlib" netstandard
          for e in m.ExportedTypes do
              resolvedTypes.[e.FullName] <-
                  lazy
                  TypeReference(e.Namespace, e.Name, m, e.Scope)
                  |> main.ImportReference
  
      let resolveAsm (name: string) =
          match assemblies.TryGetValue(name) with
          | true, x -> x
          | false, _ ->
              let x = aR.Resolve(AssemblyNameReference.Parse(name))
              assemblies.[name] <- x
              x
  
      let doResolveTypeName (asm: AssemblyDefinition) (typeName: string) =
          let ty = asm.MainModule.GetType(typeName.Replace('+', '/'))
          let ty =
              match ty with
              | null -> failwithf "Could not resolve type %s in %A" typeName asm.Name
              | ty -> if asm.Name = out.Name then ty :> TypeReference else main.ImportReference ty
          resolvedTypes.[typeName] <- lazy ty
          ty
  
      let resolveTypeName asm typeName =
          match resolvedTypes.TryGetValue(typeName) with
          | true, x -> x.Value
          | false, _ -> doResolveTypeName asm typeName
  
      let resolveType (ty: System.Type) =
          match resolvedTypes.TryGetValue(ty.FullName) with
          | true, x -> x.Value
          | false, _ ->
              let asm = resolveAsm ty.Assembly.FullName
              doResolveTypeName asm ty.FullName
  
      let genericInstance (def: TypeReference) (args: seq<TypeReference>) =
  
negative.code:         genericInstance optionType [t]    
  
      member b.Type(assemblyName: string, fullName: string) =
          match resolveAsm assemblyName fullName with
          | null -> failwithf "Could not resolve assembly: %s" assemblyName
          | asm -> resolveTypeName asm fullName
  
  