@@ -1329,6 +1329,18 @@ renderTypeError e env src = case e of
               renderType' env expectedRecordType,
             "but it was missing."
           ]
+      C.PatternMatchedMissingField fieldName fieldPat missingFieldTyp ->
+        mconcat
+          [ "This pattern tried to match on the `" <> Pr.text fieldName <> "` field, but it's not part of the type.\n",
+            "  The pattern is here: " <> Pr.lit (renderPattern env fieldPat) <> "\n",
+            "  I inferred the required type here: " <> renderType' env missingFieldTyp <> "\n"
+          ]
+      C.RecordPatternMatchOnNonRecordType recordPat nonRecordTyp ->
+        mconcat
+          [ "This pattern is trying to match a record, but the type is not a record.\n",
+            "  The pattern is here: " <> Pr.lit (renderPattern env recordPat) <> "\n",
+            "  I inferred the type here: " <> renderType' env nonRecordTyp <> "\n"
+          ]
 
 renderCompilerBug ::
   (Var v, Annotated loc, Ord loc, Show loc) =>
 
@@ -117,6 +117,7 @@ import Unison.Typechecker.TypeVar qualified as TypeVar
 import Unison.Typechecker.Variance (Variance (..), defaultVariances)
 import Unison.Var (Var)
 import Unison.Var qualified as Var
+import Witherable qualified as Wither
 
 type TypeVar v loc = TypeVar.TypeVar (B.Blank loc) v
 
@@ -503,7 +504,13 @@ data Cause v loc
       (Type v loc {- the type we expected there -})
       (Type v loc {- record literal missing the field -})
       (Type v loc {- record literal which has the type -})
-
+  | PatternMatchedMissingField
+      (Text {- the field name we tried to match, but wasn't in the type -})
+      (Pattern loc {- the place we matched on the missing field -})
+      (Type v loc {- The type of the record which is missing the field -})
+  | RecordPatternMatchOnNonRecordType
+      (Pattern loc {- the place we matched on the non-record -})
+      (Type v loc {- The type which is not a record -})
   deriving (Show)
 
 errorTerms :: ErrorNote v loc -> [Term v loc]
@@ -1732,7 +1739,22 @@ checkPattern ::
 checkPattern tx ty | (debugEnabled || debugPatternsEnabled) && traceShow ("checkPattern" :: String, tx, ty) False = undefined
 checkPattern scrutineeType p =
   case p of
-    Pattern.RecordLiteral {} -> error "Record patterns not yet implemented"
+    Pattern.RecordLiteral _loc fieldPatterns -> do
+      case scrutineeType of
+        Type.Record' fieldTypes -> do
+          vs <-
+            Align.align fieldTypes fieldPatterns
+              & Map.traverseWithKey
+                ( \fieldName -> \case
+                    This _ -> pure $ Nothing
+                    -- We have a pattern, but the expected type does not.
+                    That p -> lift . failWith $ PatternMatchedMissingField fieldName p scrutineeType
+                    These fieldTyp fieldPat -> Just <$> checkPattern fieldTyp fieldPat
+                )
+              <&> Wither.catMaybes
+          pure $ fold vs
+        _ -> do
+          lift . failWith $ RecordPatternMatchOnNonRecordType p scrutineeType
     Pattern.Unbound _ -> pure []
     Pattern.Var loc -> do
       v <- getAdvance p
 
@@ -368,6 +368,23 @@ analyseNotes codebase fileUri ppe src notes = do
                         ("expected record type", r3)
                       ]
                     )
+                Context.PatternMatchedMissingField _fieldName fieldPat recordType -> do
+                  r1 <- aToR (Pattern.loc fieldPat)
+                  r2 <- aToR (ABT.annotation recordType)
+                  pure
+                    ( r1,
+                      [ ("record type", r2)
+                      ]
+                    )
+                Context.RecordPatternMatchOnNonRecordType recordPat notRecordType ->
+                  do
+                    r1 <- aToR (Pattern.loc recordPat)
+                    r2 <- aToR (ABT.annotation notRecordType)
+                    pure
+                      ( r1,
+                        [ ("not a record type", r2)
+                        ]
+                      )
 
             shouldHaveBeenHandled e = do
               Debug.debugM Debug.LSP "This diagnostic should have been handled by a previous case but was not" e