anchor.diff:  
           let entRef = decl.Entity
           let ent = com.GetEntity(entRef)
  -        let entNamesp, entName = splitNameSpace ent.FullName
  +        let entNameSpace, entName = splitNameSpace ent.FullName
   
           let ctx = { ctx with ScopedTypeParams =
                                   ent.GenericParameters
                                   |> List.map (fun g -> g.Name)
                                   |> Set.ofList }
   
  -        let ctorImpls =
  -            if ent.IsFSharpUnion || ent.IsFSharpRecord then
  -                []
  -            else
  -                let primaryCtorItem =
  -                    match decl.Constructor with
  -                    | Some ctor ->
  -                        withCurrentScope ctx ctor.UsedNames <| fun ctx ->
  -                            transformImplicitConstructor com ctx ent ctor
  -                    | _ ->
  -                        transformCompilerGeneratedConstructor com ctx ent decl.Name
  -                    |> mkPublicAssocItem
  -                let ctorItems =
  -                    decl.AttachedMembers
  -                    |> List.filter isConstructor
  -                    |> List.map (makeMemberItem ctx)
  -                let ctorItems = primaryCtorItem :: ctorItems
  -                let genArgs = getEntityGenArgs ent
  -                let ty = transformDeclaredType com ctx entRef genArgs
  -                let generics = genArgs |> makeGenerics com ctx
  -                let implItem = mkImplItem [] "" ty generics ctorItems None
  -                [implItem]
  +        let ctorOrStaticImpls =
  +            let ctorItems =
  +                if ent.IsFSharpUnion || ent.IsFSharpRecord then
  +                    []
  +                else
  +                    let ctorItem =
  +                        match decl.Constructor with
  +                        | Some ctor ->
  +                            withCurrentScope ctx ctor.UsedNames <| fun ctx ->
  +                                transformImplicitConstructor com ctx ent ctor
  +                        | _ ->
  +                            transformCompilerGeneratedConstructor com ctx ent decl.Name
  +                    [ctorItem |> mkPublicAssocItem]
  +            let ctorOrStaticItems =
  +                decl.AttachedMembers
  +                |> List.filter isConstructorOrStatic
  +                |> List.map (makeMemberItem ctx)
  +                |> List.append ctorItems
  +            let genArgs = getEntityGenArgs ent
  +            let ty = transformDeclaredType com ctx entRef genArgs
  +            let generics = genArgs |> makeGenerics com ctx
  +            let implItem = mkImplItem [] "" ty generics ctorOrStaticItems None
  +            [implItem]
   
           let interfaces =
               ent.AllInterfaces
  
positive.code:             |> Seq.map (fun (_, members, _) -> members)
              |> Seq.fold Set.union Set.empty
  
          let nonConstructorMembersSet =
              decl.AttachedMembers
              |> List.filter (fun m -> not (isConstructor m))
              |> List.map (fun m -> m.Name)
              |> Set.ofList
  
          let nonInterfaceMembersSet =
              Set.difference nonConstructorMembersSet allInterfaceMembersSet
  
          let nonInterfaceMembersTrait =
              let membersNotDeclared =
                  decl.AttachedMembers |> List.filter (fun m ->
                      let isNotStatic = m.Args |> List.exists (fun q -> q.IsThisArgument)
                      Set.contains m.Name nonInterfaceMembersSet && isNotStatic)
              if Set.isEmpty nonInterfaceMembersSet || membersNotDeclared |> List.isEmpty then
                  []
              else
                  let traitItem =
                      let assocItems = [
                          for m in membersNotDeclared ->
                              let fnDecl = transformFunctionDecl com ctx m.Args m.Body.Type
                              let memb = com.GetMember(m.MemberRef)
                              let generics =
                                  getMemberGenArgs memb
                                  |> makeGenerics com ctx
                              let fnKind = mkFnKind DEFAULT_FN_HEADER fnDecl generics None
                              mkFnAssocItem [] m.Name fnKind
                      ]
                      let generics = getEntityGenArgs ent |> makeGenerics com ctx
                      mkTraitItem [] (entName + "Methods") assocItems [] generics
                  [traitItem |> mkPublicItem]
  
negative.code: 
      let transformAbbrev (com: IRustCompiler) ctx (ent: Fable.Entity) =
          // TODO: this is unfinished and untested
          let entNameSpace, entName = splitNameSpace ent.FullName
          let genArgs = getEntityGenArgs ent
          let ty =
              let genArgs = genArgs |> transformGenArgs com ctx
  