Rework Resolver so that we construct semantic types in a single pass.

The semantic nodes cannot be fully immutable, as they contain cyclic
references. Remove Resolver::CreateSemanticNodes(), and instead
construct and mutate the semantic nodes in the single traversal pass.

Give up on trying to maintain the 'authored' type names (aliased names).
These are a nightmare to maintain, and provided limited use.

Significantly simplfies the Resolver, and allows us to generate more
semantic to semantic references, reducing sem -> ast -> sem hops.

Note: This change introduces constant value propagation across constant
variables. This is unlocked by the earlier construction of the
sem::Variable.

Change-Id: I592092fdc47fe24d30e512952511c9ab7c16d7a1
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/68406
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: Antonio Maiorano <amaiorano@google.com>

src/transform/module_scope_var_to_entry_point_param.cc

@@ -109,8 +109,8 @@ struct ModuleScopeVarToEntryPointParam::State {
 
         // Find all of the calls to this function that will need to be replaced.
         for (auto* call : func_sem->CallSites()) {
-          auto* call_sem = ctx.src->Sem().Get(call);
-          calls_to_replace[call_sem->Stmt()->Function()].push_back(call);
+          calls_to_replace[call->Stmt()->Function()->Declaration()].push_back(
+              call->Declaration());
         }
       }
     }
@@ -268,7 +268,7 @@ struct ModuleScopeVarToEntryPointParam::State {
         // Replace all uses of the module-scope variable.
         // For non-entry points, dereference non-handle pointer parameters.
         for (auto* user : var->Users()) {
-          if (user->Stmt()->Function() == func_ast) {
+          if (user->Stmt()->Function()->Declaration() == func_ast) {
             const ast::Expression* expr = ctx.dst->Expr(new_var_symbol);
             if (is_pointer) {
               // If this identifier is used by an address-of operator, just

src/transform/robustness_test.cc

@@ -39,7 +39,7 @@ var<private> a : array<f32, 3>;
 let c : u32 = 1u;
 
 fn f() {
-  let b : f32 = a[min(c, 2u)];
+  let b : f32 = a[1u];
 }
 )";
 
@@ -807,7 +807,7 @@ struct S {
 let c : u32 = 1u;
 
 fn f() {
-  let b : f32 = s.b[min(c, (arrayLength(&(s.b)) - 1u))];
+  let b : f32 = s.b[min(1u, (arrayLength(&(s.b)) - 1u))];
   let x : i32 = min(1, 2);
   let y : u32 = arrayLength(&(s.b));
 }