anchor.diff:              match t.GetCustomAttributes(typeof<EndPointAttribute>, false) with
               | [| :? EndPointAttribute as attr |] -> attr.EndPoint
               | _ -> t.Name
  +        let fields =
  +            t.GetFields(BF.Instance ||| BF.Public ||| BF.NonPublic)
  +            |> Array.map (fun f -> nameOf f, f.FieldType)
  +            |> List.ofArray
           match s.[s.IndexOf('/') + 1 ..].Split([|'/'|], StringSplitOptions.RemoveEmptyEntries) with
           | [||] -> MetaRoot
  -        | [| name |] ->
  -            let args =
  -                t.GetFields(BF.Instance ||| BF.Public ||| BF.NonPublic)
  -                |> Array.map nameOf
  -                |> List.ofArray
  -            MetaPath (name, args)
  +        | [| name |] -> MetaPath (name, fields)
           | a ->
               let name = a.[0]
               let args =
                   a.[1..]
                   |> Array.map (fun n ->
                       if n.StartsWith "{" && n.EndsWith "}" then
  -                        n.[1..n.Length-2]
  +                        let name = n.[1..n.Length-2]
  +                        match fields |> List.tryFind (fun (n, _) -> name = n) with
  +                        | Some f -> f
  +                        | None -> failwithf "Path argument doesn't correspond to a field: %s" n
                       else
                           failwith "Path arguments must be of the shape: {fieldName}")
                   |> List.ofArray
  
positive.code:             |> Reflection.getMethod
              |> Hashed,
              [])
  
  //    let internals = Hashed { Assembly = "WebSharper.UI.Next.CSharp"; FullName = "RoutingInternals" }
  //    let getInternals() =
  
negative.code:             NewUnionCase (routeShapeT, "Path",
                  [
                      Value (String name)
                      NewArray (args |> List.map (fun (argName, argType) ->
                          let meth arg res =
                              Hashed {
                                  MethodName = argType.FullName
                                  Parameters = [arg]
                                  ReturnType = res
                                  Generics = 0
                              }
                          let argType' = Reflection.getType argType
                          let parseMeth = meth stringT (optionOf argType')
                          match comp.LookupMethodInfo(parsersT, parseMeth) with
                          | Metadata.LookupMemberError _ ->
                              failwithf "EndPoint field type not supported: %s %s" argType.FullName argName
                          | _ ->
                              let stringM =
                                  let m = Hashed {
                                      MethodName = "ToString"
                                      Parameters = [GenericType 0]
                                      ReturnType = stringT
                                      Generics = 1
                                  }
                                  concrete(m, [argType'])
                              NewArray [
                                  Value (String argName)
                                  (let x = Id.New() in Lambda ([x],
                                      Call(None, concrete(parsersT, []), concrete(parseMeth, []), [Var x])))
                                  // TODO below: link instead of just returning
                                  (let x = Id.New() in Lambda([x],
                                      Call(None, concrete(fsCoreType "Core.Operators", []), stringM, [Var x])))
                              ]))
                  ])
  
      override __.TranslateCall(_, _, m, args, _) =
  