anchor.diff:                  | Some (ILFieldItem (finfo:: _))  when (match lookupKind with LookupKind.Expr | LookupKind.Pattern -> true | _ -> false) -> 
                       success (resInfo,Item.ILField finfo,rest)
   
  -                | Some (EventItem (einfo :: _)) when (match lookupKind with LookupKind.Expr -> true | _ -> false)  -> 
  +                | Some (EventItem (einfo :: _)) when isLookUpExpr -> 
                       success (resInfo,Item.Event einfo,rest)
                   | Some (RecdFieldItem (rfinfo)) when (match lookupKind with LookupKind.Expr | LookupKind.RecdField | LookupKind.Pattern -> true | _ -> false) -> 
                       success(resInfo,Item.RecdField(rfinfo),rest)
                   | _ ->
                   let pinfos = ExtensionPropInfosOfTypeInScope ncenv.InfoReader nenv (optFilter, ad) m typ
  -                if not (List.isEmpty pinfos) && (match lookupKind with LookupKind.Expr -> true | _ -> false) then 
  +                if not (List.isEmpty pinfos) && isLookUpExpr then 
                       success (resInfo,Item.Property (nm,pinfos),rest) else
                   let minfos = ExtensionMethInfosOfTypeInScope ncenv.InfoReader nenv optFilter m typ
  -                if not (List.isEmpty minfos) && (match lookupKind with LookupKind.Expr -> true | _ -> false) then 
  +                if not (List.isEmpty minfos) && isLookUpExpr then 
                       success (resInfo,Item.MakeMethGroup (nm,minfos),rest) 
                                   
                   elif isTyparTy g typ then raze (IndeterminateType(unionRanges m id.idRange))
                   else raze (UndefinedName (depth,FSComp.SR.undefinedNameFieldConstructorOrMember, id,NoPredictions))
  +
  +           |> OneResult
  +
  +        match contentsSearchAccessible with
  +        | Result res when not (List.isEmpty res) -> contentsSearchAccessible
  +        | _ -> 
                 
           let nestedSearchAccessible = 
               let nestedTypes = GetNestedTypesOfType (ad, ncenv, Some nm, (if List.isEmpty rest then typeNameResInfo.StaticArgsInfo else TypeNameResolutionStaticArgsInfo.Indefinite), true, m) typ
  
positive.code:                 ResolveLongIdentInTyconRefs (ncenv:NameResolver) nenv LookupKind.Pattern (depth+1) m ad rest numTyArgsOpt id.idRange tcrefs
              | _ -> 
                  NoResultsOrUsefulErrors
          // Constructor of a type? 
          let ctorSearch = 
              if List.isEmpty rest then 
  
negative.code:                 let tyconSearch = tyconSearch |?> List.choose (function (resInfo,Item.RecdField(RecdFieldInfo(_,rfref)),rest) -> Some(resInfo,FieldResolution(rfref,false),rest) | _ -> None)
                  tyconSearch
              | _ -> NoResultsOrUsefulErrors
  
          let modulSearch ad = 
              ResolveLongIndentAsModuleOrNamespaceThen ncenv.amap m OpenQualified nenv ad lid 
                  (ResolveFieldInModuleOrNamespace ncenv nenv ad)
  
          let search =
              let moduleSearch1 = modulSearch ad
          
              match moduleSearch1 with
              | Result (res :: _) -> success res
              | _ -> 
  
              let tyconSearch1 = tyconSearch ad
  
              match tyconSearch1 with
              | Result (res :: _) -> success res
              | _ -> 
  
              let moduleSearch2 = modulSearch AccessibleFromSomeFSharpCode
  
              match moduleSearch2 with
              | Result (res :: _) -> success res
              | _ -> 
  
              let tyconSearch2 = tyconSearch AccessibleFromSomeFSharpCode
  
              AtMostOneResult m (moduleSearch1 +++ tyconSearch1 +++ moduleSearch2 +++ tyconSearch2)
  
          let resInfo,item,rest = ForceRaise search
          if not (List.isEmpty rest) then 
              errorR(Error(FSComp.SR.nrInvalidFieldLabel(),(List.head rest).idRange))
  
          [(resInfo,item)]
  
  let ResolveField sink ncenv nenv ad typ (mp,id) allFields =
  