anchor.diff:                          | Struct(name, fields) ->
                               
                               let! fields = 
  -                                fields |> List.mapSpvi (fun i (t,n) -> spirv { let! tid = getTypeId t in return (tid, i, n)})
  +                                fields |> List.mapSpvi (fun i (t,n,d) -> spirv { let! tid = getTypeId t in return (tid, i, n,d)})
   
                               let! id = newId
  -                            yield OpTypeStruct(id, fields |> List.map (fun (t,_,_) -> t) |> List.toArray)
  -
  -                            for (_,i,n) in fields do
  +                            yield OpTypeStruct(id, fields |> List.map (fun (t,_,_,_) -> t) |> List.toArray)
  +
  +                            for (_,i,n,_) in fields do
                                   yield OpMemberName(id, uint32 i, n)
  +
  +                            for (_,i,_,d) in fields do
  +                                for (dec, args) in d do
  +                                    yield OpMemberDecorate(id, uint32 i, dec, args)
   
                               yield OpName(id, name)
   
  
positive.code:                 buildTypeMap (Map.add id (Ptr(c, inner)) current) rest
  
              | OpTypeStruct(id, fields) :: rest ->
                  let getMemberName (i : int) =
                      match Map.tryFind (id, uint32 i) memberNames with
                          | Some n -> n
                          | None -> sprintf "f%d" i
  
                  let name =
                      match Map.tryFind id names with
                          | Some n -> n
                          | _ -> sprintf "struct%d" (int id)
  
                  let fieldTypes = fields |> Array.mapi (fun i id -> current.[id], getMemberName i) |> Array.toList
                  let t = Struct(name, fieldTypes)
                  buildTypeMap (Map.add id t current) rest
  
  
negative.code:     | Vector of compType : Type * dim : int
      | Matrix of colType : Type * dim : int
      | Array of elementType : Type * length : int
      | Struct of name : string * fields : list<Type * string * list<Decoration * uint32[]>>
      | Image of sampledType : Type * dim : Dim * depth : int * arrayed : bool * ms : int * sampled : bool * format : int
      | SampledImage of Type
      | Ptr of StorageClass * Type
  