anchor.diff:                       |> List.filter (IsTyconUnseen ad g ncenv.amap m >> not)
                        |> List.map Item.ExnCase
                | _ ->
  -                 let ilTyconNames = 
  -                     mty.TypesByAccessNames.Values
  -                     |> List.choose (fun (tycon:Tycon) -> if tycon.IsILTycon then Some tycon.DisplayName else None)
  -                     |> Set.ofList
  -
                    // Collect up the accessible sub-modules. We must yield them even though `item` is not a module or namespace, 
                    // otherwise we would not resolve long idents which have modules and namespaces in the middle (i.e. all long idents)
  -                 yield! 
  +                 
  +                 let moduleOrNamespaces = 
                        mty.ModulesAndNamespacesByDemangledName 
  -                     |> NameMap.range 
  -                     |> List.filter (fun x -> 
  -                           let demangledName = x.DemangledModuleOrNamespaceName
  -                           notFakeContainerModule ilTyconNames demangledName && IsInterestingModuleName demangledName)
  -                     |> List.map modref.NestedTyconRef
  -                     |> List.filter (IsTyconUnseen ad g ncenv.amap m >> not)
  -                     |> List.filter (EntityRefContainsSomethingAccessible ncenv m ad)
  -                     |> List.map ItemForModuleOrNamespaceRef
  +                     |> NameMap.range
  +
  +                 if not (isNil moduleOrNamespaces) then
  +                     let ilTyconNames = getFakeContainerModulesFromTycons mty.TypesByAccessNames.Values
  +                     
  +                     yield!
  +                         moduleOrNamespaces
  +                         |> List.filter (fun x -> 
  +                               let demangledName = x.DemangledModuleOrNamespaceName
  +                               notFakeContainerModule ilTyconNames demangledName && IsInterestingModuleName demangledName)
  +                         |> List.map modref.NestedTyconRef
  +                         |> List.filter (IsTyconUnseen ad g ncenv.amap m >> not)
  +                         |> List.filter (EntityRefContainsSomethingAccessible ncenv m ad)
  +                         |> List.map ItemForModuleOrNamespaceRef
  +
                    let tycons = 
                        mty.TypeDefinitions
                        |> List.filter (fun tcref -> not (tcref.LogicalName.Contains(",")))
  
positive.code:              mty.TypeDefinitions
               |> List.filter (fun tcref -> not (tcref.LogicalName.Contains(",")))
               |> List.filter (fun tycon -> not (IsTyconUnseen ad g ncenv.amap m (modref.NestedTyconRef tycon)))
  
           let ilTyconNames = 
               mty.TypesByAccessNames.Values
               |> List.choose (fun (tycon:Tycon) -> if tycon.IsILTycon then Some tycon.DisplayName else None)
               |> Set.ofList
  
           // Collect up the accessible values in the module, excluding the members
           (mty.AllValsAndMembers
  
negative.code:       let FullTypeOfPinfo(pinfo:PropInfo) = 
          let rty = pinfo.GetPropertyType(amap,m) 
          let rty = if pinfo.IsIndexer then mkRefTupledTy g (pinfo.GetParamTypes(amap, m)) --> rty else  rty 
          rty
  
        (ty
           |> AllPropInfosOfTypeInScope ncenv.InfoReader nenv (Some id,ad) IgnoreOverrides m
           |> List.filter (fun x -> x.IsStatic = statics)
  