fixed a bug in which references invoked from record expressions were not counted

Author: mbuscemi

elm/built/elm.js

@@ -15220,7 +15220,7 @@ var _user$project$ElmFile_References$refsInExpression = F4(
 		refsInExpression:
 		while (true) {
 			var _p8 = expression;
-			_v7_14:
+			_v7_15:
 			do {
 				if (_p8.ctor === '_Tuple2') {
 					switch (_p8._1.ctor) {
@@ -15351,17 +15351,27 @@ var _user$project$ElmFile_References$refsInExpression = F4(
 								A2(_user$project$Types_Imports$unaliasedModuleName, _p8._1._0, imports),
 								_user$project$Types_Reference$Reference(_p8._1._1),
 								references);
+						case 'RecordAccess':
+							var _v20 = $arguments,
+								_v21 = imports,
+								_v22 = _p8._1._0,
+								_v23 = references;
+							$arguments = _v20;
+							imports = _v21;
+							expression = _v22;
+							references = _v23;
+							continue refsInExpression;
 						case 'RecordUpdateExpression':
 							return A3(
 								_elm_lang$core$List$foldl,
 								A2(_user$project$ElmFile_References$refsInExpression, $arguments, imports),
 								references,
 								A2(_elm_lang$core$List$map, _elm_lang$core$Tuple$second, _p8._1._0.updates));
 						default:
-							break _v7_14;
+							break _v7_15;
 					}
 				} else {
-					break _v7_14;
+					break _v7_15;
 				}
 			} while(false);
 			return references;
@@ -15370,7 +15380,7 @@ var _user$project$ElmFile_References$refsInExpression = F4(
 var _user$project$ElmFile_References$collectRefsFromDeclaration = F3(
 	function (imports, declaration, references) {
 		var _p12 = declaration;
-		_v20_5:
+		_v24_5:
 		do {
 			if (_p12.ctor === '_Tuple2') {
 				switch (_p12._1.ctor) {
@@ -15397,10 +15407,10 @@ var _user$project$ElmFile_References$collectRefsFromDeclaration = F3(
 					case 'Destructuring':
 						return A4(_user$project$ElmFile_References$refsInExpression, _elm_lang$core$Set$empty, imports, _p12._1._1, references);
 					default:
-						break _v20_5;
+						break _v24_5;
 				}
 			} else {
-				break _v20_5;
+				break _v24_5;
 			}
 		} while(false);
 		return references;

elm/src/ElmFile/References.elm

@@ -106,6 +106,9 @@ refsInExpression arguments imports expression references =
         ( range, Elm.Syntax.Expression.QualifiedExpr moduleName name ) ->
             Types.References.addExternal (Types.Imports.unaliasedModuleName moduleName imports) (Reference name) references
 
+        ( range, Elm.Syntax.Expression.RecordAccess exp _ ) ->
+            refsInExpression arguments imports exp references
+
         ( range, Elm.Syntax.Expression.RecordUpdateExpression recordUpdate ) ->
             List.foldl (refsInExpression arguments imports) references (List.map Tuple.second recordUpdate.updates)
 

elm/tests/ASTParsing/NestedRecord.elm

@@ -0,0 +1,74 @@
+module ASTParsing.NestedRecord exposing (canParse)
+
+import Dict
+import ElmFile
+import Expect
+import Set
+import Test exposing (Test, describe, test)
+import Types.Expression
+import Types.Reference exposing (Reference)
+
+
+canParse : Test
+canParse =
+    describe "Nested Record Elm File" <|
+        let
+            elmFile =
+                ElmFile.fromString "Simple.elm" nestedRecordDotElm
+        in
+        [ test "has expected module name" <|
+            \_ ->
+                Expect.equal elmFile.moduleName [ "NestedRecord" ]
+        , test "has expected imports" <|
+            \_ ->
+                Expect.equal elmFile.imports
+                    { direct =
+                        Dict.empty
+                    , aliases =
+                        Dict.empty
+                    }
+        , test "has expected top level expressions" <|
+            \_ ->
+                Expect.equal elmFile.topLevelExpressions
+                    { functions =
+                        Dict.empty
+                            |> Dict.insert "someRecord" (Types.Expression.standardExpression 2)
+                            |> Dict.insert "nested" (Types.Expression.standardExpression 6)
+                    , types =
+                        Dict.empty
+                    , typeAliases =
+                        Dict.empty
+                    }
+        , test "has expected exposings" <|
+            \_ ->
+                Expect.equal elmFile.exposings
+                    { functions =
+                        Set.empty
+                            |> Set.insert "nested"
+                    , types =
+                        Set.empty
+                    }
+        , test "has expected references" <|
+            \_ ->
+                Expect.equal elmFile.references
+                    { internal =
+                        [ Reference "someRecord" ]
+                    , external =
+                        Dict.empty
+                    }
+        ]
+
+
+nestedRecordDotElm : String
+nestedRecordDotElm =
+    """module NestedRecord exposing (nested)
+
+someRecord : { a : { b : String } }
+someRecord =
+    { a = { b = "blarg" } }
+
+nested : String
+nested =
+    someRecord.a.b
+
+"""