v1 inference: generic instantiation must reach record-literal field expectations (>=2 seams) — plus the adjacent below-floor fail-open where a generic field admits the wrong type silently

src/v1/04_infer.dag

@@ -1112,6 +1112,22 @@ fn record_lit_fields_from_expected(type_name: String?, expected: Node?, scope: I
   }
 }
 
+fn field_type_expr_is_stripped_placeholder(te: Node, source_indices: Map<String, NewlineIndex>) -> Bool {
+  authored_name_at(source_indices: source_indices, node: te) == ""
+    && te.children |> count == 0
+    && te.params |> count == 0
+}
+
+fn field_substitution_carrier(sf: Node, source_indices: Map<String, NewlineIndex>) -> Node {
+  let te = field_node_type_expr(n: sf)
+  if field_type_expr_is_stripped_placeholder(te: te, source_indices: source_indices) {
+    match sf.inferred {
+      Present { value: Resolved { node: rt } } => preserve_outer_optional_cardinality(outer: sf, inner: rt)
+      _ => te
+    }
+  } else { te }
+}
+
 fn record_lit_instantiated_fields(type_name: String?, expected: Node?, scope: InferScope) -> List<Node>? {
   match type_name {
     Present { value: tn } =>
@@ -1139,7 +1155,7 @@ fn record_lit_instantiated_fields(type_name: String?, expected: Node?, scope: In
                     Node {
                       name: sf.name, span: sf.span, ident_span: sf.ident_span,
                       children: sf.children, connective: sf.connective, params: sf.params,
-                      inferred: Present { value: Resolved { node: substitute_generics(n: field_node_type_expr(n: sf), subst: subst, source_indices: scope.type_env.source_indices) } },
+                      inferred: Present { value: Resolved { node: substitute_generics(n: field_substitution_carrier(sf: sf, source_indices: scope.type_env.source_indices), subst: subst, source_indices: scope.type_env.source_indices) } },
                       return_cardinality: sf.return_cardinality, uses: sf.uses, body: sf.body,
                       transport: sf.transport, properties: sf.properties,
                       type_annotation: sf.type_annotation, is_self_recursive: sf.is_self_recursive,

src/v1/stage0/src/v1_compiler_infer.rs

@@ -1711,6 +1711,32 @@ pub fn record_lit_fields_from_expected(
     }
 }
 
+pub fn field_type_expr_is_stripped_placeholder(
+    te: Rc<Node>,
+    source_indices: Rc<HashMap<String, Rc<NewlineIndex>>>,
+) -> bool {
+    authored_name_at(source_indices.clone(), te.clone()) == *""
+        && te.children.len() == 0
+        && te.params.len() == 0
+}
+
+pub fn field_substitution_carrier(
+    sf: Rc<Node>,
+    source_indices: Rc<HashMap<String, Rc<NewlineIndex>>>,
+) -> Rc<Node> {
+    let te = field_node_type_expr(sf.clone());
+    if field_type_expr_is_stripped_placeholder(te.clone(), source_indices.clone()) {
+        match sf.inferred.as_deref() {
+            Some(InferredNode::Resolved { node: rt }) => {
+                preserve_outer_optional_cardinality(sf.clone(), rt.clone())
+            }
+            _ => te.clone(),
+        }
+    } else {
+        te.clone()
+    }
+}
+
 pub fn record_lit_instantiated_fields(
     type_name: Option<String>,
     expected: Option<Rc<Node>>,
@@ -1758,7 +1784,14 @@ match exp.children.clone().iter().cloned().skip(pair.0.clone() as usize).next()
                                                     inferred: Some(Rc::new(
                                                         InferredNode::Resolved {
                                                             node: substitute_generics(
-                                                                field_node_type_expr(sf.clone()),
+                                                                field_substitution_carrier(
+                                                                    sf.clone(),
+                                                                    scope
+                                                                        .type_env
+                                                                        .clone()
+                                                                        .source_indices
+                                                                        .clone(),
+                                                                ),
                                                                 subst.clone(),
                                                                 scope
                                                                     .type_env