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