nameof fixes (#9498)

Author: dsyme

src/absil/illib.fs

@@ -385,6 +385,11 @@ module List =
         mn 0 xs
     let count pred xs = List.fold (fun n x -> if pred x then n+1 else n) 0 xs
 
+    let headAndTail l = 
+       match l with 
+       | [] -> failwith "headAndTail"
+       | h::t -> (h,t)
+
     // WARNING: not tail-recursive 
     let mapHeadTail fhead ftail = function
       | []    -> []

src/fsharp/TypeChecker.fs

@@ -9271,38 +9271,66 @@ and TcNameOfExpr cenv env tpenv (synArg: SynExpr) =
 
     let cleanSynArg = stripParens synArg
     let m = cleanSynArg.Range
-    let rec check overallTyOpt expr (delayed: DelayedItem list) = 
+    let rec check overallTyOpt resultOpt expr (delayed: DelayedItem list) = 
         match expr with
-        | LongOrSingleIdent (false, (LongIdentWithDots((id::rest) as longId, _) as lidd), _, _) ->
+        | LongOrSingleIdent (false, (LongIdentWithDots(longId, _) as lidd), _, _) ->
             let ad = env.eAccessRights
-            match ResolveLongIndentAsModuleOrNamespaceOrStaticClass cenv.tcSink ResultCollectionSettings.AllResults cenv.amap m false true OpenQualified env.eNameResEnv ad id rest true with 
-            | Result modref when delayed.IsEmpty && modref |> List.exists (p23 >> IsEntityAccessible cenv.amap m ad) -> 
-                () // resolved to a module or namespace, done with checks
-            | _ -> 
-                let (TypeNameResolutionInfo(_, staticArgsInfo)) = GetLongIdentTypeNameInfo delayed
-                match ResolveTypeLongIdent cenv.tcSink cenv.nameResolver ItemOccurence.UseInAttribute OpenQualified env.eNameResEnv ad longId staticArgsInfo PermitDirectReferenceToGeneratedType.No with
-                | Result tcref when IsEntityAccessible cenv.amap m ad tcref -> 
-                    () // resolved to a type name, done with checks
-                | _ -> 
-                    let overallTy = match overallTyOpt with None -> NewInferenceType() | Some t -> t 
-                    let _, _ = TcLongIdentThen cenv overallTy env tpenv lidd delayed
-                    () // checked as an expression, done with checks
-            List.last longId
+            let result = defaultArg resultOpt (List.last longId)
+            let resolvedToModuleOrNamespaceName =
+                if delayed.IsEmpty then 
+                    let id,rest = List.headAndTail longId
+                    match ResolveLongIndentAsModuleOrNamespaceOrStaticClass cenv.tcSink ResultCollectionSettings.AllResults cenv.amap m false true OpenQualified env.eNameResEnv ad id rest true with 
+                    | Result modref when delayed.IsEmpty && modref |> List.exists (p23 >> IsEntityAccessible cenv.amap m ad) -> 
+                        true // resolved to a module or namespace, done with checks
+                    | _ -> 
+                        false
+                else
+                    false
+            if resolvedToModuleOrNamespaceName then result else
+
+            let resolvedToTypeName = 
+                if (match delayed with [DelayedTypeApp _] | [] -> true | _ -> false) then
+                    let (TypeNameResolutionInfo(_, staticArgsInfo)) = GetLongIdentTypeNameInfo delayed
+                    match ResolveTypeLongIdent cenv.tcSink cenv.nameResolver ItemOccurence.UseInAttribute OpenQualified env.eNameResEnv ad longId staticArgsInfo PermitDirectReferenceToGeneratedType.No with
+                    | Result tcref when (match delayed with [DelayedTypeApp _] | [] -> true | _ -> false) && IsEntityAccessible cenv.amap m ad tcref -> 
+                        true // resolved to a type name, done with checks
+                    | _ -> 
+                        false
+                else
+                    false
+            if resolvedToTypeName then result else
 
+            let overallTy = match overallTyOpt with None -> NewInferenceType() | Some t -> t 
+            
+            // This will raise an error if resolution doesn't succeed
+            let _, _ = TcLongIdentThen cenv overallTy env tpenv lidd delayed
+            result // checked as an expression, done with checks
+            
+        // expr<tyargs> allowed, even with qualifications 
         | SynExpr.TypeApp (hd, _, types, _, _, _, m) ->
-            check overallTyOpt hd (DelayedTypeApp(types, m, m) :: delayed)
+            check overallTyOpt resultOpt hd (DelayedTypeApp(types, m, m) :: delayed)
 
-        | SynExpr.Paren(expr, _, _, _) when overallTyOpt.IsNone && delayed.IsEmpty -> 
-            check overallTyOpt expr []
+        // expr.ID allowed 
+        | SynExpr.DotGet (hd, _, LongIdentWithDots(longId, _), _) ->
+            let result = defaultArg resultOpt (List.last longId)
+            check overallTyOpt (Some result) hd ((DelayedDotLookup (longId, expr.RangeSansAnyExtraDot)) :: delayed)
 
+        // "(expr)" allowed with no subsequent qualifications
+        | SynExpr.Paren(expr, _, _, _) when delayed.IsEmpty && overallTyOpt.IsNone -> 
+            check overallTyOpt resultOpt expr delayed
+
+        // expr : type" allowed with no subsequent qualifications
         | SynExpr.Typed (synBodyExpr, synType, _m) when delayed.IsEmpty && overallTyOpt.IsNone ->
             let tgtTy, _tpenv = TcTypeAndRecover cenv NewTyparsOK CheckCxs ItemOccurence.UseInType  env tpenv synType
-            check (Some tgtTy) synBodyExpr []
+            check (Some tgtTy) resultOpt synBodyExpr delayed
 
         | _ -> 
             error (Error(FSComp.SR.expressionHasNoName(), m))
 
-    let lastIdent = check None cleanSynArg [] 
+    let lastIdent = check None None cleanSynArg [] 
+    TcNameOfExprResult cenv lastIdent m
+
+and TcNameOfExprResult cenv (lastIdent: Ident) m = 
     let constRange = mkRange m.FileName m.Start (mkPos m.StartLine (m.StartColumn + lastIdent.idText.Length + 2)) // `2` are for quotes
     Expr.Const(Const.String(lastIdent.idText), constRange, cenv.g.string_ty)
 
@@ -9825,8 +9853,21 @@ and TcItemThen cenv overallTy env tpenv (item, mItem, rest, afterResolution) del
             //   - it isn't a CtorValUsedAsSuperInit 
             //   - it isn't a CtorValUsedAsSelfInit 
             //   - it isn't a VSlotDirectCall (uses of base values do not take type arguments 
+            // Allow `nameof<'T>` for a generic parameter
+            match vref with
+            | _ when isNameOfValRef cenv.g vref && cenv.g.langVersion.SupportsFeature LanguageFeature.NameOf ->
+                match tys with 
+                | [SynType.Var((Typar(id, _, false) as tp), _m)] -> 
+                    let _tp', tpenv = TcTyparOrMeasurePar None cenv env ImplicitlyBoundTyparsAllowed.NoNewTypars tpenv tp
+                    let vexp = TcNameOfExprResult cenv id mExprAndTypeArgs
+                    let vexpFlex = MakeApplicableExprNoFlex cenv vexp
+                    PropagateThenTcDelayed cenv overallTy env tpenv mExprAndTypeArgs vexpFlex cenv.g.string_ty ExprAtomicFlag.Atomic otherDelayed
+                | _ ->
+                    error (Error(FSComp.SR.expressionHasNoName(), mExprAndTypeArgs))
+            | _ -> 
             let checkTys tpenv kinds = TcTypesOrMeasures (Some kinds) cenv NewTyparsOK CheckCxs ItemOccurence.UseInType env tpenv tys mItem
             let _, vexp, isSpecial, _, _, tpenv = TcVal true cenv env tpenv vref (Some (NormalValUse, checkTys)) (Some afterResolution) mItem
+            
             let vexpFlex = (if isSpecial then MakeApplicableExprNoFlex cenv vexp else MakeApplicableExprWithFlex cenv env vexp)
             // We need to eventually record the type resolution for an expression, but this is done
             // inside PropagateThenTcDelayed, so we don't have to explicitly call 'CallExprHasTypeSink' here            

src/fsharp/TypedTreeOps.fsi

@@ -2279,7 +2279,11 @@ val (|EnumExpr|_|) : TcGlobals -> Expr -> Expr option
 val (|TypeOfExpr|_|) : TcGlobals -> Expr -> TType option
 
 val (|TypeDefOfExpr|_|) : TcGlobals -> Expr -> TType option
+
+val isNameOfValRef: TcGlobals -> ValRef -> bool
+
 val (|NameOfExpr|_|) : TcGlobals -> Expr -> TType option
+
 val (|SeqExpr|_|) : TcGlobals -> Expr -> unit option
 
 val EvalLiteralExprOrAttribArg: TcGlobals -> Expr -> Expr

tests/fsharp/core/nameof/preview/test.fsx

@@ -103,6 +103,14 @@ type BasicNameOfTests() =
         let b = nameof(this.MemberMethod)
         Assert.AreEqual("MemberMethod", b)
 
+    member this.``can get name of instance member via unchecked`` () =
+        let b = nameof(Unchecked.defaultof<BasicNameOfTests>.MemberMethod)
+        Assert.AreEqual("MemberMethod", b)
+
+    member this.``can get name of method type parameter``<'TTT> () =
+        let b = nameof<'TTT>
+        Assert.AreEqual("TTT", b)
+
     static member ``namespace name`` () =
         let b = nameof(FSharp.Core)
         Assert.AreEqual("Core",b)
@@ -297,6 +305,7 @@ do test "can get name from inside a local function (needs to be let rec)"
 do test "can get name from inside static member"        (BasicNameOfTests.``can get name from inside static member`` ())
 do test "can get name from inside instance member"      ((BasicNameOfTests()).``can get name from inside instance member`` ())
 do test "can get name of instance member"               ((BasicNameOfTests()).``can get name of instance member`` ())
+do test "can get name of instance member via unchecked" ((BasicNameOfTests()).``can get name of instance member via unchecked`` ())
 do test "namespace name"                                (BasicNameOfTests.``namespace name`` ())
 do test "module name"                                   (BasicNameOfTests.``module name`` ())
 do test "exception name"                                (BasicNameOfTests.``exception name`` ())

tests/fsharp/core/nameof/version46/test.fsx

@@ -341,68 +341,3 @@ module Foo =
     let nameof = ()
     let x = name ()
 
-do test "local variable name lookup"                    (BasicNameOfTests.``local variable name lookup`` ())
-do test "local int function name"                       (BasicNameOfTests.``local int function name`` ())
-do test "local curried function name"                   (BasicNameOfTests.``local curried function name`` ())
-do test "local tupled function name"                    (BasicNameOfTests.``local tupled function name`` ())
-do test "local unit function name"                      (BasicNameOfTests.``local unit function name`` ())
-do test "local function parameter name"                 (BasicNameOfTests.``local function parameter name`` ())
-do test "can get name from inside a local function (needs to be let rec)"
-                                                        (BasicNameOfTests.``can get name from inside a local function (needs to be let rec)`` ())
-do test "can get name from inside static member"        (BasicNameOfTests.``can get name from inside static member`` ())
-do test "can get name from inside instance member"      ((BasicNameOfTests()).``can get name from inside instance member`` ())
-do test "can get name of instance member"               ((BasicNameOfTests()).``can get name of instance member`` ())
-do test "namespace name"                                (BasicNameOfTests.``namespace name`` ())
-do test "module name"                                   (BasicNameOfTests.``module name`` ())
-do test "exception name"                                (BasicNameOfTests.``exception name`` ())
-do test "nested type name 1"                            (BasicNameOfTests.``nested type name 1`` ())
-do test "type name 2"                                   (BasicNameOfTests.``type name 2`` ())
-do test "member function which is defined below"        (BasicNameOfTests.``member function which is defined below`` ())
-do test "class member lookup"                           ((BasicNameOfTests()).``class member lookup`` ())
-do test "static member function name"                   (BasicNameOfTests.``static member function name`` ())
-do test "static property name"                          (BasicNameOfTests.``static property name`` ())
-do test "member method starting with get_"              (BasicNameOfTests.``member method starting with get_`` ())
-do test "static method starting with get_"              (BasicNameOfTests.``static method starting with get_`` ())
-do test "nameof local property with encapsulated name"  (BasicNameOfTests.``nameof local property with encapsulated name`` ())
-
-do test "single argument method group name lookup"      ((MethodGroupNameOfTests()).``single argument method group name lookup`` ())
-do test "multiple argument method group name lookup"    ((MethodGroupNameOfTests()).``multiple argument method group name lookup`` ())
-
-do test "measure 1"                                     ((UnionAndRecordNameOfTests()).``measure 1`` ())
-do test "record case 1"                                 ((UnionAndRecordNameOfTests()).``record case 1`` ())
-do test "union case 1"                                  ((UnionAndRecordNameOfTests()).``union case 1`` ())
-do test "union case 2"                                  ((UnionAndRecordNameOfTests()).``union case 2`` ())
-
-do test "ok in attribute"                               ((AttributeNameOfTests()).``ok in attribute`` ())
-
-do test "lookup name of typeof operator"                ((OperatorNameOfTests()).``lookup name of typeof operator`` ())
-do test "lookup name of + operator"                     ((OperatorNameOfTests()).``lookup name of + operator`` ())
-do test "lookup name of |> operator"                    ((OperatorNameOfTests()).``lookup name of |> operator`` ())
-do test "lookup name of nameof operator"                ((OperatorNameOfTests()).``lookup name of nameof operator`` ())
-
-do test "use it as a match case guard"                  ((PatternMatchingOfOperatorNameTests()).``use it as a match case guard`` ())
-
-do test "se it in a quotation"                          ((NameOfOperatorInQuotations()).``use it in a quotation`` ())
-
-do test "use it in a generic function"                  ((NameOfOperatorForGenerics()).``use it in a generic function`` ())
-do test "lookup name of a generic class"                ((NameOfOperatorForGenerics()).``lookup name of a generic class`` ())
-
-do test "user defined nameof should shadow the operator"(UserDefinedNameOfTests.``user defined nameof should shadow the operator`` ())
-
-#if TESTS_AS_APP
-let RUN() = 
-  match !failures with 
-  | [] -> stdout.WriteLine "Test Passed"
-  | _ ->  stdout.WriteLine "Test Failed"
-#else
-let aa =
-  match !failures with 
-  | [] ->
-      stdout.WriteLine "Test Passed"
-      System.IO.File.WriteAllText("test.ok","ok")
-      exit 0
-  | _ -> 
-      stdout.WriteLine "Test Failed"
-      exit 1
-#endif
-