fixup! Add EEP for native records

Author: bjorng

eeps/eep-0079.md

@@ -345,6 +345,8 @@ bugs to either runtime or when Dialyzer is run.
 
 #### Validation
 
+NOT_REVIEWED_BY_OTB.
+
 A native record creation is validated at runtime against the
 native record definition. Creation fails in the following
 cases.
@@ -408,13 +410,15 @@ The following syntax allows accessing field `Field` in any record:
 Expr#_.Field
 ```
 
-This access operation fails with a `{badfield,Field}` error if:
-
-* The field `Field` is not defined in the native-record value.
+An access operation fails with a `{badrecord,Expr}` error if:
 
 * The definition of the record was not exported when the native-record
   value was created, and it is now used outside its defining module.
 
+This access operation fails with a `{badfield,Field}` error if:
+
+* The field `Field` is not defined in the native-record value.
+
 ### Updating native records
 
 The syntax for updating native-record values:
@@ -777,6 +781,63 @@ create non-exported from any module.
 
 The functions in the `records` module are BIFs.
 
+### Compile-time checking of records
+
+NOT_REVIEWED_BY_OTB.
+
+Attempting to create a local record values that lacks a definition is
+a compilation error. So is referring to a non-existing field name in
+an existing record.
+
+Therefore, both attempts to create records in the following module
+are compilation errors:
+
+```erlang
+-module(compilation_errors).
+-record #empty{}.
+
+create1() ->
+    #empty{whatever=42}.
+
+create2() ->
+    #unknown_record{}.
+```
+
+Those creation operations are always compilation errors because they
+could never succeed at runtime.
+
+All other operations operating on undefined entities result in
+compilation warnings. The reason is that they would succeed at runtime
+when operating on a record from another version of the same module.
+
+For example, the following operations will all result in a warning:
+
+```erlang
+-module(compilation_warnings).
+-record #empty{}.
+
+access1(R) ->
+    R#empty.x.
+
+access2(R) ->
+    R#unknown_record.x.
+
+update1(R) ->
+    R#empty{unknown=42}.
+
+update2(R) ->
+    R#unknown_record{x=0}.
+
+match1(#empty{x=X}) ->
+    X.
+
+match2(#unknown_record{x=X}) ->
+    X.
+```
+
+The compiler checks neither anonymous operations nor operations on
+external records.
+
 ### Printing
 
 Here is how printed native-records will look like: