anchor.diff:                      let rest = ts.[7] :?> Mono.Cecil.GenericInstanceType
                       Array.append ts.[.. 6] (collect rest.GenericArguments) 
                   else ts
  -            let tts = collect tR.GenericArguments |> Seq.map (getType tgen) |> List.ofSeq
  +            let tts = collect tR.GenericArguments |> Seq.map (getType isTSasm tgen) |> List.ofSeq
               TupleType (tts, isStruct)
           if name = "System.Void" || name = "Microsoft.FSharp.Core.Unit" then
               VoidType
           elif name = "Microsoft.FSharp.Core.FSharpFunc`2" then
               let tR = tR :?> Mono.Cecil.GenericInstanceType
  -            match tR.GenericArguments |> Seq.map (getType tgen) |> List.ofSeq with
  +            match tR.GenericArguments |> Seq.map (getType isTSasm tgen) |> List.ofSeq with
               | [a; r] -> FSharpFuncType(a, r)    
               | _ -> failwith "FSharpFunc type must have two type arguments"
           elif name.StartsWith "System.Tuple" then
  
positive.code:                     let mdef =
                          Hashed {
                              MethodName = meth.Name
                              Parameters = meth.Parameters |> Seq.map (fun p -> getType tgen p.ParameterType) |> List.ofSeq
                              ReturnType = getType tgen meth.ReturnType
                              Generics   = meth.GenericParameters |> Seq.length
                          }
                      let mNode = graph.AddOrLookupNode(MethodNode (def, mdef))
                      graph.AddEdge(mNode, clsNodeIndex)
                      for req in getRequires meth.CustomAttributes do
                          graph.AddEdge(mNode, ResourceNode req)
                      
                      if not meth.IsStatic then hasInstanceMethod <- true
  
negative.code:         else None
      )
  
  let getRequires isTSasm attrs =
      attrs
      |> Seq.filter (fun (a: Mono.Cecil.CustomAttribute) -> 
          a.AttributeType.FullName = "WebSharper.RequireAttribute" 
      )
      |> Seq.map (fun a ->
          let cargs = a.ConstructorArguments 
          cargs.[0].Value :?> Mono.Cecil.TypeReference |> getTypeDefinition isTSasm
          ,
          if cargs.Count = 1 then None else (cargs.[1].Value |> ParameterObject.OfObj |> Some)
      )
      |> List.ofSeq
  
  let getMacros isTSasm attrs =
      attrs
      |> Seq.filter (fun (a: Mono.Cecil.CustomAttribute) -> 
          a.AttributeType.FullName = "WebSharper.MacroAttribute" 
      )
      |> Seq.map (fun a ->
          let ar = a.ConstructorArguments
          getTypeDefinition isTSasm (ar.[0].Value :?> _)
          ,
          if ar.Count > 1 then
              // Todo : System.Type parameter objects
  