diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 15c84cd..58129fb 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -90,8 +90,6 @@
   ast/identifier_expression.h
   ast/if_statement.cc
   ast/if_statement.h
-  ast/import.cc
-  ast/import.h
   ast/int_literal.cc
   ast/int_literal.h
   ast/intrinsic.cc
@@ -319,7 +317,6 @@
   ast/function_test.cc
   ast/identifier_expression_test.cc
   ast/if_statement_test.cc
-  ast/import_test.cc
   ast/int_literal_test.cc
   ast/location_decoration_test.cc
   ast/loop_statement_test.cc
@@ -439,7 +436,6 @@
     reader/wgsl/parser_impl_global_variable_decl_test.cc
     reader/wgsl/parser_impl_if_stmt_test.cc
     reader/wgsl/parser_impl_image_storage_type_test.cc
-    reader/wgsl/parser_impl_import_decl_test.cc
     reader/wgsl/parser_impl_inclusive_or_expression_test.cc
     reader/wgsl/parser_impl_logical_and_expression_test.cc
     reader/wgsl/parser_impl_logical_or_expression_test.cc
@@ -538,7 +534,6 @@
     writer/wgsl/generator_impl_function_test.cc
     writer/wgsl/generator_impl_identifier_test.cc
     writer/wgsl/generator_impl_if_test.cc
-    writer/wgsl/generator_impl_import_test.cc
     writer/wgsl/generator_impl_loop_test.cc
     writer/wgsl/generator_impl_member_accessor_test.cc
     writer/wgsl/generator_impl_return_test.cc
diff --git a/src/ast/identifier_expression.cc b/src/ast/identifier_expression.cc
index d14d5f4..375387e 100644
--- a/src/ast/identifier_expression.cc
+++ b/src/ast/identifier_expression.cc
@@ -18,62 +18,27 @@
 namespace ast {
 
 IdentifierExpression::IdentifierExpression(const std::string& name)
-    : Expression(), segments_({name}) {}
+    : Expression(), name_(name) {}
 
 IdentifierExpression::IdentifierExpression(const Source& source,
                                            const std::string& name)
-    : Expression(source), segments_({name}) {}
-
-IdentifierExpression::IdentifierExpression(std::vector<std::string> segments)
-    : Expression(), segments_(std::move(segments)) {}
-
-IdentifierExpression::IdentifierExpression(const Source& source,
-                                           std::vector<std::string> segments)
-    : Expression(source), segments_(std::move(segments)) {}
+    : Expression(source), name_(name) {}
 
 IdentifierExpression::IdentifierExpression(IdentifierExpression&&) = default;
 
 IdentifierExpression::~IdentifierExpression() = default;
 
-std::string IdentifierExpression::path() const {
-  if (segments_.size() < 2) {
-    return "";
-  }
-
-  std::string path = "";
-  // We skip the last segment as that's the name, not part of the path
-  for (size_t i = 0; i < segments_.size() - 1; ++i) {
-    if (i > 0) {
-      path += "::";
-    }
-    path += segments_[i];
-  }
-  return path;
-}
-
 bool IdentifierExpression::IsIdentifier() const {
   return true;
 }
 
 bool IdentifierExpression::IsValid() const {
-  if (segments_.size() == 0)
-    return false;
-
-  for (const auto& segment : segments_) {
-    if (segment.size() == 0)
-      return false;
-  }
-  return true;
+  return !name_.empty();
 }
 
 void IdentifierExpression::to_str(std::ostream& out, size_t indent) const {
   make_indent(out, indent);
-  out << "Identifier{";
-  if (has_path()) {
-    out << path() << "::";
-  }
-  out << name();
-  out << "}" << std::endl;
+  out << "Identifier{" << name_ << "}" << std::endl;
 }
 
 }  // namespace ast
diff --git a/src/ast/identifier_expression.h b/src/ast/identifier_expression.h
index e45cd8f..af08b69 100644
--- a/src/ast/identifier_expression.h
+++ b/src/ast/identifier_expression.h
@@ -16,10 +16,9 @@
 #define SRC_AST_IDENTIFIER_EXPRESSION_H_
 
 #include <string>
-#include <utility>
-#include <vector>
 
 #include "src/ast/expression.h"
+#include "src/ast/intrinsic.h"
 
 namespace tint {
 namespace ast {
@@ -34,31 +33,20 @@
   /// @param source the source
   /// @param name the name
   IdentifierExpression(const Source& source, const std::string& name);
-  /// Constructor
-  /// @param segments the name segments
-  explicit IdentifierExpression(std::vector<std::string> segments);
-  /// Constructor
-  /// @param source the identifier expression source
-  /// @param segments the name segments
-  IdentifierExpression(const Source& source, std::vector<std::string> segments);
   /// Move constructor
   IdentifierExpression(IdentifierExpression&&);
   ~IdentifierExpression() override;
 
-  /// Sets the name segments
-  /// @param segments the name segments
-  void set_segments(std::vector<std::string> segments) {
-    segments_ = std::move(segments);
-  }
-  /// @returns the name
-  std::vector<std::string> segments() const { return segments_; }
-
-  /// @returns true if this identifier has a path component
-  bool has_path() const { return segments_.size() > 1; }
-  /// @returns the path part of the identifier or blank if no path
-  std::string path() const;
   /// @returns the name part of the identifier
-  std::string name() const { return segments_.back(); }
+  std::string name() const { return name_; }
+
+  /// Sets the intrinsic for this identifier
+  /// @param i the intrinsic to set
+  void set_intrinsic(Intrinsic i) { intrinsic_ = i; }
+  /// @returns the intrinsic this identifier represents
+  Intrinsic intrinsic() const { return intrinsic_; }
+  /// @returns true if this identifier is for an intrinsic
+  bool IsIntrinsic() const { return intrinsic_ != Intrinsic::kNone; }
 
   /// @returns true if this is an identifier expression
   bool IsIdentifier() const override;
@@ -74,7 +62,8 @@
  private:
   IdentifierExpression(const IdentifierExpression&) = delete;
 
-  std::vector<std::string> segments_;
+  Intrinsic intrinsic_ = Intrinsic::kNone;
+  std::string name_;
 };
 
 }  // namespace ast
diff --git a/src/ast/identifier_expression_test.cc b/src/ast/identifier_expression_test.cc
index 0886953..ad0ff98 100644
--- a/src/ast/identifier_expression_test.cc
+++ b/src/ast/identifier_expression_test.cc
@@ -24,19 +24,11 @@
 
 TEST_F(IdentifierExpressionTest, Creation) {
   IdentifierExpression i("ident");
-  ASSERT_EQ(i.segments().size(), 1u);
-  EXPECT_EQ(i.segments()[0], "ident");
-  EXPECT_EQ(i.path(), "");
   EXPECT_EQ(i.name(), "ident");
 }
 
 TEST_F(IdentifierExpressionTest, Creation_WithSource) {
-  IdentifierExpression i(Source{20, 2}, {"ns1", "ns2", "ident"});
-  ASSERT_EQ(i.segments().size(), 3u);
-  EXPECT_EQ(i.segments()[0], "ns1");
-  EXPECT_EQ(i.segments()[1], "ns2");
-  EXPECT_EQ(i.segments()[2], "ident");
-  EXPECT_EQ(i.path(), "ns1::ns2");
+  IdentifierExpression i(Source{20, 2}, "ident");
   EXPECT_EQ(i.name(), "ident");
 
   auto src = i.source();
@@ -54,21 +46,11 @@
   EXPECT_TRUE(i.IsValid());
 }
 
-TEST_F(IdentifierExpressionTest, IsValid_WithNamespaces) {
-  IdentifierExpression i({"ns1", "n2", "ident"});
-  EXPECT_TRUE(i.IsValid());
-}
-
 TEST_F(IdentifierExpressionTest, IsValid_BlankName) {
   IdentifierExpression i("");
   EXPECT_FALSE(i.IsValid());
 }
 
-TEST_F(IdentifierExpressionTest, IsValid_BlankNamespace) {
-  IdentifierExpression i({"ns1", "", "ident"});
-  EXPECT_FALSE(i.IsValid());
-}
-
 TEST_F(IdentifierExpressionTest, ToStr) {
   IdentifierExpression i("ident");
   std::ostringstream out;
@@ -77,14 +59,6 @@
 )");
 }
 
-TEST_F(IdentifierExpressionTest, ToStr_WithNamespace) {
-  IdentifierExpression i({"ns1", "ns2", "ident"});
-  std::ostringstream out;
-  i.to_str(out, 2);
-  EXPECT_EQ(out.str(), R"(  Identifier{ns1::ns2::ident}
-)");
-}
-
 }  // namespace
 }  // namespace ast
 }  // namespace tint
diff --git a/src/ast/import.cc b/src/ast/import.cc
deleted file mode 100644
index b86c6b1..0000000
--- a/src/ast/import.cc
+++ /dev/null
@@ -1,60 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/ast/import.h"
-
-#include <cctype>
-
-namespace tint {
-namespace ast {
-
-Import::Import() = default;
-
-Import::Import(const std::string& path, const std::string& name)
-    : Node(), path_(path), name_(name) {}
-
-Import::Import(const Source& source,
-               const std::string& path,
-               const std::string& name)
-    : Node(source), path_(path), name_(name) {}
-
-Import::Import(Import&&) = default;
-
-Import::~Import() = default;
-
-bool Import::IsValid() const {
-  if (path_.length() == 0) {
-    return false;
-  }
-
-  auto len = name_.length();
-  if (len == 0) {
-    return false;
-  }
-
-  // Verify the import name ends in a character, number or _
-  if (len > 2 && !std::isalnum(name_[len - 1]) && name_[len] != '_') {
-    return false;
-  }
-
-  return true;
-}
-
-void Import::to_str(std::ostream& out, size_t indent) const {
-  make_indent(out, indent);
-  out << R"(Import{")" + path_ + R"(" as )" + name_ + "}" << std::endl;
-}
-
-}  // namespace ast
-}  // namespace tint
diff --git a/src/ast/import.h b/src/ast/import.h
deleted file mode 100644
index 5f40188..0000000
--- a/src/ast/import.h
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_AST_IMPORT_H_
-#define SRC_AST_IMPORT_H_
-
-#include <memory>
-#include <ostream>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include "src/ast/node.h"
-
-namespace tint {
-namespace ast {
-
-/// An import statement.
-class Import : public Node {
- public:
-  /// Create a new empty import statement
-  Import();
-  /// Create a new import statement
-  /// @param path The import path e.g. GLSL.std.450
-  /// @param name The import reference name e.g. std
-  Import(const std::string& path, const std::string& name);
-  /// Create a new import statement
-  /// @param source The input source for the import statement
-  /// @param path The import path e.g. GLSL.std.430
-  /// @param name The import reference name e.g. std
-  Import(const Source& source,
-         const std::string& path,
-         const std::string& name);
-  /// Move constructor
-  Import(Import&&);
-
-  ~Import() override;
-
-  /// Sets the import path
-  /// @param path the path to set
-  void set_path(const std::string& path) { path_ = path; }
-  /// @returns the import path
-  const std::string& path() const { return path_; }
-  /// Sets the import name
-  /// @param name the name to set
-  void set_name(const std::string& name) { name_ = name; }
-  /// @returns the import name
-  const std::string& name() const { return name_; }
-
-  /// Add the given |name| to map to the given |id|
-  /// @param name the name to map
-  /// @param id the id to map too
-  void AddMethodId(const std::string& name, uint32_t id) {
-    method_to_id_map_[name] = id;
-  }
-
-  /// Retrieves the id for a given name
-  /// @param name the name to lookup
-  /// @returns the id for the given name or 0 on failure
-  uint32_t GetIdForMethod(const std::string& name) const {
-    auto val = method_to_id_map_.find(name);
-    if (val == method_to_id_map_.end()) {
-      return 0;
-    }
-    return val->second;
-  }
-
-  /// @returns true if the name and path are both present
-  bool IsValid() const override;
-
-  /// Writes a representation of the node to the output stream
-  /// @param out the stream to write to
-  /// @param indent number of spaces to indent the node when writing
-  void to_str(std::ostream& out, size_t indent) const override;
-
- private:
-  Import(const Import&) = delete;
-
-  std::string path_;
-  std::string name_;
-  std::unordered_map<std::string, uint32_t> method_to_id_map_;
-};
-
-/// A list of unique imports
-using ImportList = std::vector<std::unique_ptr<Import>>;
-
-}  // namespace ast
-}  // namespace tint
-
-#endif  // SRC_AST_IMPORT_H_
diff --git a/src/ast/import_test.cc b/src/ast/import_test.cc
deleted file mode 100644
index af77bab..0000000
--- a/src/ast/import_test.cc
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/ast/import.h"
-
-#include <sstream>
-
-#include "gtest/gtest.h"
-
-namespace tint {
-namespace ast {
-namespace {
-
-using ImportTest = testing::Test;
-
-TEST_F(ImportTest, Creation) {
-  Import i("GLSL.std.430", "std::glsl");
-
-  EXPECT_EQ(i.path(), "GLSL.std.430");
-  EXPECT_EQ(i.name(), "std::glsl");
-  EXPECT_EQ(i.line(), 0u);
-  EXPECT_EQ(i.column(), 0u);
-}
-
-TEST_F(ImportTest, CreationWithSource) {
-  Source s{27, 4};
-  Import i(s, "GLSL.std.430", "std::glsl");
-
-  EXPECT_EQ(i.path(), "GLSL.std.430");
-  EXPECT_EQ(i.name(), "std::glsl");
-  EXPECT_EQ(i.line(), 27u);
-  EXPECT_EQ(i.column(), 4u);
-}
-
-TEST_F(ImportTest, CreationEmpty) {
-  Source s{27, 4};
-  Import i;
-  i.set_source(s);
-  i.set_path("GLSL.std.430");
-  i.set_name("std::glsl");
-
-  EXPECT_EQ(i.path(), "GLSL.std.430");
-  EXPECT_EQ(i.name(), "std::glsl");
-  EXPECT_EQ(i.line(), 27u);
-  EXPECT_EQ(i.column(), 4u);
-}
-
-TEST_F(ImportTest, to_str) {
-  Import i{"GLSL.std.430", "std::glsl"};
-  std::ostringstream out;
-  i.to_str(out, 2);
-  EXPECT_EQ(out.str(), "  Import{\"GLSL.std.430\" as std::glsl}\n");
-}
-
-TEST_F(ImportTest, IsValid) {
-  Import i{"GLSL.std.430", "std::glsl"};
-  EXPECT_TRUE(i.IsValid());
-}
-
-TEST_F(ImportTest, IsValid_MissingPath) {
-  Import i{"", "std::glsl"};
-  EXPECT_FALSE(i.IsValid());
-}
-
-TEST_F(ImportTest, IsValid_MissingName) {
-  Import i{"GLSL.std.430", ""};
-  EXPECT_FALSE(i.IsValid());
-}
-
-TEST_F(ImportTest, IsValid_MissingBoth) {
-  Import i;
-  EXPECT_FALSE(i.IsValid());
-}
-
-TEST_F(ImportTest, IsValid_InvalidEndingCharacter) {
-  Import i{"GLSL.std.430", "std::glsl::"};
-  EXPECT_FALSE(i.IsValid());
-}
-
-}  // namespace
-}  // namespace ast
-}  // namespace tint
diff --git a/src/ast/intrinsic.cc b/src/ast/intrinsic.cc
index da5a855..6006bcb 100644
--- a/src/ast/intrinsic.cc
+++ b/src/ast/intrinsic.cc
@@ -16,37 +16,242 @@
 
 namespace tint {
 namespace ast {
+
+std::ostream& operator<<(std::ostream& out, Intrinsic i) {
+  switch (i) {
+    case Intrinsic::kAbs:
+      out << "abs";
+      break;
+    case Intrinsic::kAcos:
+      out << "acos";
+      break;
+    case Intrinsic::kAll:
+      out << "all";
+      break;
+    case Intrinsic::kAny:
+      out << "any";
+      break;
+    case Intrinsic::kAsin:
+      out << "asin";
+      break;
+    case Intrinsic::kAtan:
+      out << "atan";
+      break;
+    case Intrinsic::kAtan2:
+      out << "atan2";
+      break;
+    case Intrinsic::kCeil:
+      out << "ceil";
+      break;
+    case Intrinsic::kClamp:
+      out << "clamp";
+      break;
+    case Intrinsic::kCos:
+      out << "cos";
+      break;
+    case Intrinsic::kCosh:
+      out << "cosh";
+      break;
+    case Intrinsic::kCountOneBits:
+      out << "countOneBits";
+      break;
+    case Intrinsic::kCross:
+      out << "cross";
+      break;
+    case Intrinsic::kDeterminant:
+      out << "determinant";
+      break;
+    case Intrinsic::kDistance:
+      out << "distance";
+      break;
+    case Intrinsic::kDot:
+      out << "dot";
+      break;
+    case Intrinsic::kDpdx:
+      out << "dpdx";
+      break;
+    case Intrinsic::kDpdxCoarse:
+      out << "dpdxCoarse";
+      break;
+    case Intrinsic::kDpdxFine:
+      out << "dpdxFine";
+      break;
+    case Intrinsic::kDpdy:
+      out << "dpdy";
+      break;
+    case Intrinsic::kDpdyCoarse:
+      out << "dpdyCoarse";
+      break;
+    case Intrinsic::kDpdyFine:
+      out << "dpdyFine";
+      break;
+    case Intrinsic::kExp:
+      out << "exp";
+      break;
+    case Intrinsic::kExp2:
+      out << "exp2";
+      break;
+    case Intrinsic::kFaceForward:
+      out << "faceForward";
+      break;
+    case Intrinsic::kFloor:
+      out << "floor";
+      break;
+    case Intrinsic::kFma:
+      out << "fma";
+      break;
+    case Intrinsic::kFract:
+      out << "fract";
+      break;
+    case Intrinsic::kFrexp:
+      out << "frexp";
+      break;
+    case Intrinsic::kFwidth:
+      out << "fwidth";
+      break;
+    case Intrinsic::kFwidthCoarse:
+      out << "fwidthCoarse";
+      break;
+    case Intrinsic::kFwidthFine:
+      out << "fwidthFine";
+      break;
+    case Intrinsic::kInverseSqrt:
+      out << "inverseSqrt";
+      break;
+    case Intrinsic::kIsFinite:
+      out << "isFinite";
+      break;
+    case Intrinsic::kIsInf:
+      out << "isInf";
+      break;
+    case Intrinsic::kIsNan:
+      out << "isNan";
+      break;
+    case Intrinsic::kIsNormal:
+      out << "isNormal";
+      break;
+    case Intrinsic::kLdexp:
+      out << "ldexp";
+      break;
+    case Intrinsic::kLength:
+      out << "length";
+      break;
+    case Intrinsic::kLog:
+      out << "log";
+      break;
+    case Intrinsic::kLog2:
+      out << "log2";
+      break;
+    case Intrinsic::kMax:
+      out << "max";
+      break;
+    case Intrinsic::kMin:
+      out << "min";
+      break;
+    case Intrinsic::kMix:
+      out << "mix";
+      break;
+    case Intrinsic::kModf:
+      out << "modf";
+      break;
+    case Intrinsic::kNormalize:
+      out << "normalize";
+      break;
+    case Intrinsic::kOuterProduct:
+      out << "outerProduct";
+      break;
+    case Intrinsic::kPow:
+      out << "pow";
+      break;
+    case Intrinsic::kReflect:
+      out << "reflect";
+      break;
+    case Intrinsic::kReverseBits:
+      out << "reverseBits";
+      break;
+    case Intrinsic::kRound:
+      out << "round";
+      break;
+    case Intrinsic::kSelect:
+      out << "select";
+      break;
+    case Intrinsic::kSign:
+      out << "sign";
+      break;
+    case Intrinsic::kSin:
+      out << "sin";
+      break;
+    case Intrinsic::kSinh:
+      out << "sinh";
+      break;
+    case Intrinsic::kSmoothStep:
+      out << "smoothStep";
+      break;
+    case Intrinsic::kSqrt:
+      out << "sqrt";
+      break;
+    case Intrinsic::kStep:
+      out << "step";
+      break;
+    case Intrinsic::kTan:
+      out << "tan";
+      break;
+    case Intrinsic::kTanh:
+      out << "tanh";
+      break;
+    case Intrinsic::kTextureLoad:
+      out << "textureLoad";
+      break;
+    case Intrinsic::kTextureSample:
+      out << "textureSample";
+      break;
+    case Intrinsic::kTextureSampleBias:
+      out << "textureSampleBias";
+      break;
+    case Intrinsic::kTextureSampleCompare:
+      out << "textureSampleCompare";
+      break;
+    case Intrinsic::kTextureSampleLevel:
+      out << "textureSampleLevel";
+      break;
+    case Intrinsic::kTrunc:
+      out << "trunc";
+      break;
+    default:
+      out << "Unknown";
+      break;
+  }
+  return out;
+}
+
 namespace intrinsic {
 
-bool IsCoarseDerivative(const std::string& name) {
-  return name == "dpdxCoarse" || name == "dpdyCoarse" || name == "fwidthCoarse";
+bool IsCoarseDerivative(ast::Intrinsic i) {
+  return i == Intrinsic::kDpdxCoarse ||
+         i == Intrinsic::kDpdyCoarse | i == Intrinsic::kFwidthCoarse;
 }
 
-bool IsFineDerivative(const std::string& name) {
-  return name == "dpdxFine" || name == "dpdyFine" || name == "fwidthFine";
+bool IsFineDerivative(ast::Intrinsic i) {
+  return i == Intrinsic::kDpdxFine || i == Intrinsic::kDpdyFine ||
+         i == Intrinsic::kFwidthFine;
 }
 
-bool IsDerivative(const std::string& name) {
-  return name == "dpdx" || name == "dpdy" || name == "fwidth" ||
-         IsCoarseDerivative(name) || IsFineDerivative(name);
+bool IsDerivative(ast::Intrinsic i) {
+  return i == Intrinsic::kDpdx || i == Intrinsic::kDpdy ||
+         i == Intrinsic::kFwidth || IsCoarseDerivative(i) ||
+         IsFineDerivative(i);
 }
 
-bool IsFloatClassificationIntrinsic(const std::string& name) {
-  return name == "isFinite" || name == "isInf" || name == "isNan" ||
-         name == "isNormal";
+bool IsFloatClassificationIntrinsic(ast::Intrinsic i) {
+  return i == Intrinsic::kIsFinite || i == Intrinsic::kIsInf ||
+         i == Intrinsic::kIsNan || i == Intrinsic::kIsNormal;
 }
 
-bool IsTextureOperationIntrinsic(const std::string& name) {
-  return name == "textureLoad" || name == "textureSample" ||
-         name == "textureSampleLevel" || name == "textureSampleBias" ||
-         name == "textureSampleCompare";
-}
-
-bool IsIntrinsic(const std::string& name) {
-  return IsDerivative(name) || name == "all" || name == "any" ||
-         IsFloatClassificationIntrinsic(name) ||
-         IsTextureOperationIntrinsic(name) || name == "dot" ||
-         name == "outerProduct" || name == "select";
+bool IsTextureIntrinsic(ast::Intrinsic i) {
+  return i == Intrinsic::kTextureLoad || i == Intrinsic::kTextureSample ||
+         i == Intrinsic::kTextureSampleLevel ||
+         i == Intrinsic::kTextureSampleBias ||
+         i == Intrinsic::kTextureSampleCompare;
 }
 
 }  // namespace intrinsic
diff --git a/src/ast/intrinsic.h b/src/ast/intrinsic.h
index 1196db9..c66f749 100644
--- a/src/ast/intrinsic.h
+++ b/src/ast/intrinsic.h
@@ -15,41 +15,111 @@
 #ifndef SRC_AST_INTRINSIC_H_
 #define SRC_AST_INTRINSIC_H_
 
+#include <ostream>
 #include <string>
 
 namespace tint {
 namespace ast {
+
+enum class Intrinsic {
+  kNone = -1,
+
+  kAbs,
+  kAcos,
+  kAll,
+  kAny,
+  kAsin,
+  kAtan,
+  kAtan2,
+  kCeil,
+  kClamp,
+  kCos,
+  kCosh,
+  kCountOneBits,
+  kCross,
+  kDeterminant,
+  kDistance,
+  kDot,
+  kDpdx,
+  kDpdxCoarse,
+  kDpdxFine,
+  kDpdy,
+  kDpdyCoarse,
+  kDpdyFine,
+  kExp,
+  kExp2,
+  kFaceForward,
+  kFloor,
+  kFma,
+  kFract,
+  kFrexp,
+  kFwidth,
+  kFwidthCoarse,
+  kFwidthFine,
+  kInverseSqrt,
+  kIsFinite,
+  kIsInf,
+  kIsNan,
+  kIsNormal,
+  kLdexp,
+  kLength,
+  kLog,
+  kLog2,
+  kMax,
+  kMin,
+  kMix,
+  kModf,
+  kNormalize,
+  kOuterProduct,
+  kPow,
+  kReflect,
+  kReverseBits,
+  kRound,
+  kSelect,
+  kSign,
+  kSin,
+  kSinh,
+  kSmoothStep,
+  kSqrt,
+  kStep,
+  kTan,
+  kTanh,
+  kTextureLoad,
+  kTextureSample,
+  kTextureSampleBias,
+  kTextureSampleCompare,
+  kTextureSampleLevel,
+  kTrunc
+};
+
+std::ostream& operator<<(std::ostream& out, Intrinsic i);
+
 namespace intrinsic {
 
 /// Determines if the given |name| is a coarse derivative
-/// @param name the name to check
+/// @param i the intrinsic
 /// @returns true if the given derivative is coarse.
-bool IsCoarseDerivative(const std::string& name);
+bool IsCoarseDerivative(ast::Intrinsic i);
 
 /// Determines if the given |name| is a fine derivative
-/// @param name the name to check
+/// @param i the intrinsic
 /// @returns true if the given derivative is fine.
-bool IsFineDerivative(const std::string& name);
+bool IsFineDerivative(ast::Intrinsic i);
 
 /// Determine if the given |name| is a derivative intrinsic
-/// @param name the name to check
+/// @param i the intrinsic
 /// @returns true if the given |name| is a derivative intrinsic
-bool IsDerivative(const std::string& name);
+bool IsDerivative(ast::Intrinsic i);
 
 /// Determines if the given |name| is a float classification intrinsic
-/// @param name the name to check
+/// @param i the intrinsic
 /// @returns true if the given |name| is a float intrinsic
-bool IsFloatClassificationIntrinsic(const std::string& name);
+bool IsFloatClassificationIntrinsic(ast::Intrinsic i);
 
 /// Determines if the given |name| is a texture operation intrinsic
-/// @param name the name to check
+/// @param i the intrinsic
 /// @returns true if the given |name| is a texture operation intrinsic
-bool IsTextureOperationIntrinsic(const std::string& name);
-
-/// Determines if the given |name| is an intrinsic
-/// @param name the name to check
-/// @returns true if the given |name| is an intrinsic
-bool IsIntrinsic(const std::string& name);
+bool IsTextureIntrinsic(ast::Intrinsic i);
 
 }  // namespace intrinsic
 }  // namespace ast
diff --git a/src/ast/module.cc b/src/ast/module.cc
index b650a78..b595aa7 100644
--- a/src/ast/module.cc
+++ b/src/ast/module.cc
@@ -27,15 +27,6 @@
 
 Module::~Module() = default;
 
-Import* Module::FindImportByName(const std::string& name) const {
-  for (const auto& import : imports_) {
-    if (import->name() == name) {
-      return import.get();
-    }
-  }
-  return nullptr;
-}
-
 Function* Module::FindFunctionByName(const std::string& name) const {
   for (const auto& func : functions_) {
     if (func->name() == name) {
@@ -56,11 +47,6 @@
 }
 
 bool Module::IsValid() const {
-  for (const auto& import : imports_) {
-    if (import == nullptr || !import->IsValid()) {
-      return false;
-    }
-  }
   for (const auto& var : global_variables_) {
     if (var == nullptr || !var->IsValid()) {
       return false;
@@ -84,9 +70,6 @@
 
   out << "Module{" << std::endl;
   const auto indent = 2;
-  for (const auto& import : imports_) {
-    import->to_str(out, indent);
-  }
   for (const auto& var : global_variables_) {
     var->to_str(out, indent);
   }
diff --git a/src/ast/module.h b/src/ast/module.h
index cb8f13a..134e762 100644
--- a/src/ast/module.h
+++ b/src/ast/module.h
@@ -21,7 +21,6 @@
 #include <vector>
 
 #include "src/ast/function.h"
-#include "src/ast/import.h"
 #include "src/ast/type/alias_type.h"
 #include "src/ast/variable.h"
 
@@ -36,18 +35,6 @@
   Module(Module&&);
   ~Module();
 
-  /// Add the given import to the module
-  /// @param import The import to add.
-  void AddImport(std::unique_ptr<Import> import) {
-    imports_.push_back(std::move(import));
-  }
-  /// @returns the imports for this module
-  const ImportList& imports() const { return imports_; }
-  /// Find the import of the given name
-  /// @param name The import name to search for
-  /// @returns the import with the given name if found, nullptr otherwise.
-  Import* FindImportByName(const std::string& name) const;
-
   /// Add a global variable to the module
   /// @param var the variable to add
   void AddGlobalVariable(std::unique_ptr<Variable> var) {
@@ -94,7 +81,6 @@
  private:
   Module(const Module&) = delete;
 
-  ImportList imports_;
   VariableList global_variables_;
   // The alias types are owned by the type manager
   std::vector<type::AliasType*> alias_types_;
diff --git a/src/ast/module_test.cc b/src/ast/module_test.cc
index e1cec96..50c3982 100644
--- a/src/ast/module_test.cc
+++ b/src/ast/module_test.cc
@@ -19,7 +19,6 @@
 
 #include "gmock/gmock.h"
 #include "src/ast/function.h"
-#include "src/ast/import.h"
 #include "src/ast/type/f32_type.h"
 #include "src/ast/variable.h"
 
@@ -32,7 +31,7 @@
 TEST_F(ModuleTest, Creation) {
   Module m;
 
-  EXPECT_EQ(m.imports().size(), 0u);
+  EXPECT_EQ(m.functions().size(), 0u);
 }
 
 TEST_F(ModuleTest, ToStrEmitsPreambleAndPostamble) {
@@ -42,44 +41,6 @@
   EXPECT_EQ(str, expected);
 }
 
-TEST_F(ModuleTest, Imports) {
-  Module m;
-
-  m.AddImport(std::make_unique<Import>("GLSL.std.430", "std::glsl"));
-  m.AddImport(std::make_unique<Import>("OpenCL.debug.100", "std::debug"));
-
-  EXPECT_EQ(2u, m.imports().size());
-  EXPECT_EQ("std::glsl", m.imports()[0]->name());
-}
-
-TEST_F(ModuleTest, ToStrWithImport) {
-  Module m;
-  m.AddImport(std::make_unique<Import>("GLSL.std.430", "std::glsl"));
-  const auto str = m.to_str();
-  EXPECT_EQ(str, R"(Module{
-  Import{"GLSL.std.430" as std::glsl}
-}
-)");
-}
-
-TEST_F(ModuleTest, LookupImport) {
-  Module m;
-
-  auto i = std::make_unique<Import>("GLSL.std.430", "std::glsl");
-  m.AddImport(std::move(i));
-  m.AddImport(std::make_unique<Import>("OpenCL.debug.100", "std::debug"));
-
-  auto* import = m.FindImportByName("std::glsl");
-  ASSERT_NE(nullptr, import);
-  EXPECT_EQ(import->path(), "GLSL.std.430");
-  EXPECT_EQ(import->name(), "std::glsl");
-}
-
-TEST_F(ModuleTest, LookupImportMissing) {
-  Module m;
-  EXPECT_EQ(nullptr, m.FindImportByName("Missing"));
-}
-
 TEST_F(ModuleTest, LookupFunction) {
   type::F32Type f32;
   Module m;
@@ -100,24 +61,6 @@
   EXPECT_TRUE(m.IsValid());
 }
 
-TEST_F(ModuleTest, IsValid_Import) {
-  Module m;
-  m.AddImport(std::make_unique<Import>("GLSL.std.430", "std::glsl"));
-  EXPECT_TRUE(m.IsValid());
-}
-
-TEST_F(ModuleTest, IsValid_Null_Import) {
-  Module m;
-  m.AddImport(nullptr);
-  EXPECT_FALSE(m.IsValid());
-}
-
-TEST_F(ModuleTest, IsValid_Invalid_Import) {
-  Module m;
-  m.AddImport(std::make_unique<Import>());
-  EXPECT_FALSE(m.IsValid());
-}
-
 TEST_F(ModuleTest, IsValid_GlobalVariable) {
   type::F32Type f32;
   auto var = std::make_unique<Variable>("var", StorageClass::kInput, &f32);
diff --git a/src/reader/spirv/function.cc b/src/reader/spirv/function.cc
index 23052e2..320dd08 100644
--- a/src/reader/spirv/function.cc
+++ b/src/reader/spirv/function.cc
@@ -327,7 +327,7 @@
     case GLSLstd450Normalize:
       return "normalize";
     case GLSLstd450FClamp:
-      return "fclamp";
+      return "clamp";
     case GLSLstd450Length:
       return "length";
     default:
@@ -2805,8 +2805,8 @@
     Fail() << "unhandled GLSL.std.450 instruction " << ext_opcode;
     return {};
   }
-  auto func = std::make_unique<ast::IdentifierExpression>(
-      std::vector<std::string>{parser_impl_.GlslStd450Prefix(), name});
+
+  auto func = std::make_unique<ast::IdentifierExpression>(name);
   ast::ExpressionList operands;
   // All parameters to GLSL.std.450 extended instructions are IDs.
   for (uint32_t iarg = 2; iarg < inst.NumInOperands(); ++iarg) {
diff --git a/src/reader/spirv/function_glsl_std_450_test.cc b/src/reader/spirv/function_glsl_std_450_test.cc
index a73187e..0f38e75 100644
--- a/src/reader/spirv/function_glsl_std_450_test.cc
+++ b/src/reader/spirv/function_glsl_std_450_test.cc
@@ -434,30 +434,28 @@
 
 INSTANTIATE_TEST_SUITE_P(Samples,
                          SpvParserTest_GlslStd450_Float_Floating,
-                         ::testing::Values(GlslStd450Case{
-                             "Length", "std::glsl::length"}));
+                         ::testing::Values(GlslStd450Case{"Length", "length"}));
 
 INSTANTIATE_TEST_SUITE_P(Samples,
                          SpvParserTest_GlslStd450_Float_FloatingFloating,
-                         ::testing::Values(GlslStd450Case{
-                             "Distance", "std::glsl::distance"}));
+                         ::testing::Values(GlslStd450Case{"Distance",
+                                                          "distance"}));
 
-INSTANTIATE_TEST_SUITE_P(
-    Samples,
-    SpvParserTest_GlslStd450_Floating_Floating,
-    ::testing::Values(GlslStd450Case{"Sin", "std::glsl::sin"},
-                      GlslStd450Case{"Cos", "std::glsl::cos"},
-                      GlslStd450Case{"Normalize", "std::glsl::normalize"}));
+INSTANTIATE_TEST_SUITE_P(Samples,
+                         SpvParserTest_GlslStd450_Floating_Floating,
+                         ::testing::Values(GlslStd450Case{"Sin", "sin"},
+                                           GlslStd450Case{"Cos", "cos"},
+                                           GlslStd450Case{"Normalize",
+                                                          "normalize"}));
 
 INSTANTIATE_TEST_SUITE_P(Samples,
                          SpvParserTest_GlslStd450_Floating_FloatingFloating,
-                         ::testing::Values(GlslStd450Case{"Atan2",
-                                                          "std::glsl::atan2"}));
+                         ::testing::Values(GlslStd450Case{"Atan2", "atan2"}));
 
 INSTANTIATE_TEST_SUITE_P(
     Samples,
     SpvParserTest_GlslStd450_Floating_FloatingFloatingFloating,
-    ::testing::Values(GlslStd450Case{"FClamp", "std::glsl::fclamp"}));
+    ::testing::Values(GlslStd450Case{"FClamp", "clamp"}));
 
 }  // namespace
 }  // namespace spirv
diff --git a/src/reader/spirv/parser_impl.cc b/src/reader/spirv/parser_impl.cc
index cb05f29..9c6c87d 100644
--- a/src/reader/spirv/parser_impl.cc
+++ b/src/reader/spirv/parser_impl.cc
@@ -453,7 +453,6 @@
   type_mgr_ = nullptr;
   deco_mgr_ = nullptr;
 
-  import_map_.clear();
   glsl_std_450_imports_.clear();
 }
 
@@ -544,14 +543,6 @@
         reinterpret_cast<const char*>(import.GetInOperand(0).words.data()));
     // TODO(dneto): Handle other extended instruction sets when needed.
     if (name == "GLSL.std.450") {
-      // Only create the AST import once, so we can use import name 'std::glsl'.
-      // This is a canonicalization.
-      if (glsl_std_450_imports_.empty()) {
-        auto ast_import =
-            std::make_unique<tint::ast::Import>(name, GlslStd450Prefix());
-        import_map_[import.result_id()] = ast_import.get();
-        ast_module_.AddImport(std::move(ast_import));
-      }
       glsl_std_450_imports_.insert(import.result_id());
     } else {
       return Fail() << "Unrecognized extended instruction set: " << name;
diff --git a/src/reader/spirv/parser_impl.h b/src/reader/spirv/parser_impl.h
index 8f6abfa..555c77f 100644
--- a/src/reader/spirv/parser_impl.h
+++ b/src/reader/spirv/parser_impl.h
@@ -32,7 +32,6 @@
 #include "source/opt/types.h"
 #include "spirv-tools/libspirv.hpp"
 #include "src/ast/expression.h"
-#include "src/ast/import.h"
 #include "src/ast/module.h"
 #include "src/ast/struct_member_decoration.h"
 #include "src/ast/type/alias_type.h"
@@ -136,9 +135,6 @@
     return glsl_std_450_imports_;
   }
 
-  /// @returns the import prefix to use for the GLSL.std.450 import.
-  std::string GlslStd450Prefix() const { return "std::glsl"; }
-
   /// Converts a SPIR-V type to a Tint type, and saves it for fast lookup.
   /// If the type is only used for builtins, then register that specially,
   /// and return null.
@@ -460,8 +456,6 @@
   // instruction is line 1.
   std::unordered_map<const spvtools::opt::Instruction*, Source> inst_source_;
 
-  /// Maps a SPIR-V ID for an external instruction import to an AST import
-  std::unordered_map<uint32_t, ast::Import*> import_map_;
   // The set of IDs that are imports of the GLSL.std.450 extended instruction
   // sets.
   std::unordered_set<uint32_t> glsl_std_450_imports_;
diff --git a/src/reader/spirv/parser_impl_import_test.cc b/src/reader/spirv/parser_impl_import_test.cc
index afa78a3..b72445b 100644
--- a/src/reader/spirv/parser_impl_import_test.cc
+++ b/src/reader/spirv/parser_impl_import_test.cc
@@ -44,23 +44,6 @@
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   EXPECT_TRUE(p->error().empty());
   EXPECT_THAT(p->glsl_std_450_imports(), ElementsAre(1));
-  const auto module_ast = p->module().to_str();
-  EXPECT_THAT(module_ast, HasSubstr(R"(Import{"GLSL.std.450" as std::glsl})"));
-}
-
-TEST_F(SpvParserTest, Import_ImportGlslStd450Twice) {
-  auto* p = parser(test::Assemble(R"(
-    %1  = OpExtInstImport "GLSL.std.450"
-    %42 = OpExtInstImport "GLSL.std.450"
-  )"));
-  EXPECT_TRUE(p->BuildAndParseInternalModule());
-  EXPECT_TRUE(p->error().empty());
-  EXPECT_THAT(p->glsl_std_450_imports(), UnorderedElementsAre(1, 42));
-  const auto module = p->module();
-  EXPECT_EQ(module.imports().size(), 1u);
-  const auto module_ast = module.to_str();
-  // TODO(dneto): Use a matcher to show there is only one import.
-  EXPECT_THAT(module_ast, HasSubstr(R"(Import{"GLSL.std.450" as std::glsl})"));
 }
 
 // TODO(dneto): We don't currently support other kinds of extended instruction
diff --git a/src/reader/wgsl/parser_impl.cc b/src/reader/wgsl/parser_impl.cc
index 6a41627..64a0649 100644
--- a/src/reader/wgsl/parser_impl.cc
+++ b/src/reader/wgsl/parser_impl.cc
@@ -203,7 +203,6 @@
 
 // global_decl
 //  : SEMICOLON
-//  | import_decl SEMICOLON
 //  | global_variable_decl SEMICLON
 //  | global_constant_decl SEMICOLON
 //  | type_alias SEMICOLON
@@ -218,19 +217,6 @@
     return;
   }
 
-  auto import = import_decl();
-  if (has_error())
-    return;
-  if (import != nullptr) {
-    t = next();
-    if (!t.IsSemicolon()) {
-      set_error(t, "missing ';' for import");
-      return;
-    }
-    module_.AddImport(std::move(import));
-    return;
-  }
-
   auto gv = global_variable_decl();
   if (has_error())
     return;
@@ -281,69 +267,6 @@
   set_error(t);
 }
 
-// import_decl
-//  : IMPORT STRING_LITERAL AS (IDENT NAMESPACE)* IDENT
-std::unique_ptr<ast::Import> ParserImpl::import_decl() {
-  auto t = peek();
-  if (!t.IsImport())
-    return {};
-
-  auto source = t.source();
-  next();  // consume the import token
-
-  t = next();
-  if (!t.IsStringLiteral()) {
-    set_error(t, "missing path for import");
-    return {};
-  }
-  auto path = t.to_str();
-  if (path.length() == 0) {
-    set_error(t, "import path must not be empty");
-    return {};
-  }
-
-  t = next();
-  if (!t.IsAs()) {
-    set_error(t, "missing 'as' for import");
-    return {};
-  }
-
-  std::string name = "";
-  for (;;) {
-    t = peek();
-    if (!t.IsIdentifier()) {
-      break;
-    }
-    next();  // consume the peek
-
-    name += t.to_str();
-
-    t = peek();
-    if (!t.IsNamespace()) {
-      break;
-    }
-    next();  // consume the peek
-
-    name += "::";
-  }
-  if (name.length() == 0) {
-    if (t.IsEof() || t.IsSemicolon()) {
-      set_error(t, "missing name for import");
-    } else {
-      set_error(t, "invalid name for import");
-    }
-    return {};
-  }
-  if (name.length() > 2) {
-    auto end = name.length() - 1;
-    if (name[end] == ':' && name[end - 1] == ':') {
-      set_error(t, "invalid name for import");
-      return {};
-    }
-  }
-  return std::make_unique<ast::Import>(source, path, name);
-}
-
 // global_variable_decl
 //  : variable_decoration_list variable_decl
 //  | variable_decoration_list variable_decl EQUAL const_expr
@@ -2840,7 +2763,7 @@
 }
 
 // primary_expression
-//   : (IDENT NAMESPACE)* IDENT
+//   : IDENT
 //   | type_decl PAREN_LEFT argument_expression_list* PAREN_RIGHT
 //   | const_literal
 //   | paren_rhs_stmt
@@ -2911,24 +2834,7 @@
   } else if (t.IsIdentifier()) {
     next();  // Consume the peek
 
-    std::vector<std::string> ident;
-    ident.push_back(t.to_str());
-    for (;;) {
-      t = peek();
-      if (!t.IsNamespace())
-        break;
-
-      next();  // Consume the peek
-      t = next();
-      if (!t.IsIdentifier()) {
-        set_error(t, "identifier expected");
-        return nullptr;
-      }
-
-      ident.push_back(t.to_str());
-    }
-    return std::make_unique<ast::IdentifierExpression>(source,
-                                                       std::move(ident));
+    return std::make_unique<ast::IdentifierExpression>(source, t.to_str());
   }
 
   auto* type = type_decl();
diff --git a/src/reader/wgsl/parser_impl.h b/src/reader/wgsl/parser_impl.h
index 2574958..5cc5248 100644
--- a/src/reader/wgsl/parser_impl.h
+++ b/src/reader/wgsl/parser_impl.h
@@ -28,7 +28,6 @@
 #include "src/ast/constructor_expression.h"
 #include "src/ast/else_statement.h"
 #include "src/ast/function.h"
-#include "src/ast/import.h"
 #include "src/ast/literal.h"
 #include "src/ast/loop_statement.h"
 #include "src/ast/module.h"
@@ -123,9 +122,6 @@
   void translation_unit();
   /// Parses the `global_decl` grammar element
   void global_decl();
-  /// Parses the `import_decl grammar element
-  /// @returns the import object or nullptr if an error was encountered
-  std::unique_ptr<ast::Import> import_decl();
   /// Parses a `global_variable_decl` grammar element
   /// @returns the variable parsed or nullptr
   std::unique_ptr<ast::Variable> global_variable_decl();
diff --git a/src/reader/wgsl/parser_impl_global_decl_test.cc b/src/reader/wgsl/parser_impl_global_decl_test.cc
index 432f2e1..404f559 100644
--- a/src/reader/wgsl/parser_impl_global_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_global_decl_test.cc
@@ -27,35 +27,6 @@
   ASSERT_FALSE(p->has_error()) << p->error();
 }
 
-TEST_F(ParserImplTest, GlobalDecl_Import) {
-  auto* p = parser(R"(import "GLSL.std.430" as glsl;)");
-  p->global_decl();
-  ASSERT_FALSE(p->has_error()) << p->error();
-
-  auto m = p->module();
-  ASSERT_EQ(1u, m.imports().size());
-
-  const auto& import = m.imports()[0];
-  EXPECT_EQ("GLSL.std.430", import->path());
-  EXPECT_EQ("glsl", import->name());
-}
-
-TEST_F(ParserImplTest, GlobalDecl_Import_Invalid) {
-  auto* p = parser(R"(import as glsl;)");
-  p->global_decl();
-
-  ASSERT_TRUE(p->has_error());
-  EXPECT_EQ(p->error(), "1:8: missing path for import");
-}
-
-TEST_F(ParserImplTest, GlobalDecl_Import_Invalid_MissingSemicolon) {
-  auto* p = parser(R"(import "GLSL.std.430" as glsl)");
-  p->global_decl();
-
-  ASSERT_TRUE(p->has_error());
-  EXPECT_EQ(p->error(), "1:30: missing ';' for import");
-}
-
 TEST_F(ParserImplTest, GlobalDecl_GlobalVariable) {
   auto* p = parser("var<out> a : vec2<i32> = vec2<i32>(1, 2);");
   p->global_decl();
diff --git a/src/reader/wgsl/parser_impl_import_decl_test.cc b/src/reader/wgsl/parser_impl_import_decl_test.cc
deleted file mode 100644
index abf4582..0000000
--- a/src/reader/wgsl/parser_impl_import_decl_test.cc
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "gtest/gtest.h"
-#include "src/reader/wgsl/parser_impl.h"
-#include "src/reader/wgsl/parser_impl_test_helper.h"
-
-namespace tint {
-namespace reader {
-namespace wgsl {
-namespace {
-
-TEST_F(ParserImplTest, ImportDecl_Import) {
-  auto* p = parser(R"(import "GLSL.std.450" as glsl)");
-
-  auto import = p->import_decl();
-  ASSERT_NE(import, nullptr);
-  ASSERT_FALSE(p->has_error()) << p->error();
-
-  EXPECT_EQ("GLSL.std.450", import->path());
-  EXPECT_EQ("glsl", import->name());
-  EXPECT_EQ(1u, import->line());
-  EXPECT_EQ(1u, import->column());
-}
-
-TEST_F(ParserImplTest, ImportDecl_Import_WithNamespace) {
-  auto* p = parser(R"(import "GLSL.std.450" as std::glsl)");
-  auto import = p->import_decl();
-  ASSERT_NE(import, nullptr);
-  ASSERT_FALSE(p->has_error()) << p->error();
-  EXPECT_EQ("std::glsl", import->name());
-}
-
-TEST_F(ParserImplTest, ImportDecl_Invalid_MissingPath) {
-  auto* p = parser(R"(import as glsl)");
-  auto import = p->import_decl();
-  ASSERT_EQ(import, nullptr);
-  ASSERT_TRUE(p->has_error());
-  EXPECT_EQ(p->error(), "1:8: missing path for import");
-}
-
-TEST_F(ParserImplTest, ImportDecl_Invalid_EmptyPath) {
-  auto* p = parser(R"(import "" as glsl)");
-  auto import = p->import_decl();
-  ASSERT_EQ(import, nullptr);
-  ASSERT_TRUE(p->has_error());
-  EXPECT_EQ(p->error(), "1:8: import path must not be empty");
-}
-
-TEST_F(ParserImplTest, ImportDecl_Invalid_NameMissingTerminatingIdentifier) {
-  auto* p = parser(R"(import "GLSL.std.450" as glsl::)");
-  auto import = p->import_decl();
-  ASSERT_EQ(import, nullptr);
-  ASSERT_TRUE(p->has_error());
-  EXPECT_EQ(p->error(), "1:32: invalid name for import");
-}
-
-TEST_F(ParserImplTest, ImportDecl_Invalid_NameInvalid) {
-  auto* p = parser(R"(import "GLSL.std.450" as 12glsl)");
-  auto import = p->import_decl();
-  ASSERT_EQ(import, nullptr);
-  ASSERT_TRUE(p->has_error());
-  EXPECT_EQ(p->error(), "1:26: invalid name for import");
-}
-
-TEST_F(ParserImplTest, ImportDecl_Invalid_MissingName) {
-  auto* p = parser(R"(import "GLSL.std.450" as)");
-  auto import = p->import_decl();
-  ASSERT_EQ(import, nullptr);
-  ASSERT_TRUE(p->has_error());
-  EXPECT_EQ(p->error(), "1:25: missing name for import");
-}
-
-TEST_F(ParserImplTest, ImportDecl_Invalid_MissingAs) {
-  auto* p = parser(R"(import "GLSL.std.450" glsl)");
-  auto import = p->import_decl();
-  ASSERT_EQ(import, nullptr);
-  ASSERT_TRUE(p->has_error());
-  EXPECT_EQ(p->error(), "1:23: missing 'as' for import");
-}
-
-}  // namespace
-}  // namespace wgsl
-}  // namespace reader
-}  // namespace tint
diff --git a/src/reader/wgsl/parser_impl_postfix_expression_test.cc b/src/reader/wgsl/parser_impl_postfix_expression_test.cc
index 9baf8a6..4ec04b2 100644
--- a/src/reader/wgsl/parser_impl_postfix_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_postfix_expression_test.cc
@@ -105,7 +105,7 @@
 }
 
 TEST_F(ParserImplTest, PostfixExpression_Call_WithArgs) {
-  auto* p = parser("std::test(1, b, 2 + 3 / b)");
+  auto* p = parser("test(1, b, 2 + 3 / b)");
   auto e = p->postfix_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -115,7 +115,6 @@
 
   ASSERT_TRUE(c->func()->IsIdentifier());
   auto* func = c->func()->AsIdentifier();
-  EXPECT_EQ(func->path(), "std");
   EXPECT_EQ(func->name(), "test");
 
   EXPECT_EQ(c->params().size(), 3u);
diff --git a/src/reader/wgsl/parser_impl_primary_expression_test.cc b/src/reader/wgsl/parser_impl_primary_expression_test.cc
index c2558e9..e6a4265 100644
--- a/src/reader/wgsl/parser_impl_primary_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_primary_expression_test.cc
@@ -43,25 +43,6 @@
   EXPECT_EQ(ident->name(), "a");
 }
 
-TEST_F(ParserImplTest, PrimaryExpression_Ident_WithNamespace) {
-  auto* p = parser("a::b::c::d");
-  auto e = p->primary_expression();
-  ASSERT_FALSE(p->has_error()) << p->error();
-  ASSERT_NE(e, nullptr);
-  ASSERT_TRUE(e->IsIdentifier());
-  auto* ident = e->AsIdentifier();
-  EXPECT_EQ(ident->path(), "a::b::c");
-  EXPECT_EQ(ident->name(), "d");
-}
-
-TEST_F(ParserImplTest, PrimaryExpression_Ident_MissingIdent) {
-  auto* p = parser("a::");
-  auto e = p->primary_expression();
-  ASSERT_TRUE(p->has_error());
-  ASSERT_EQ(e, nullptr);
-  EXPECT_EQ(p->error(), "1:4: identifier expected");
-}
-
 TEST_F(ParserImplTest, PrimaryExpression_TypeDecl) {
   auto* p = parser("vec4<i32>(1, 2, 3, 4))");
   auto e = p->primary_expression();
diff --git a/src/reader/wgsl/parser_impl_test.cc b/src/reader/wgsl/parser_impl_test.cc
index 7b6a5a0..a9fb584 100644
--- a/src/reader/wgsl/parser_impl_test.cc
+++ b/src/reader/wgsl/parser_impl_test.cc
@@ -30,8 +30,6 @@
 
 TEST_F(ParserImplTest, Parses) {
   auto* p = parser(R"(
-import "GLSL.std.430" as glsl;
-
 [[location(0)]] var<out> gl_FragColor : vec4<f32>;
 
 [[stage(vertex)]]
@@ -42,22 +40,19 @@
   ASSERT_TRUE(p->Parse()) << p->error();
 
   auto m = p->module();
-  ASSERT_EQ(1u, m.imports().size());
   ASSERT_EQ(1u, m.functions().size());
   ASSERT_EQ(1u, m.global_variables().size());
 }
 
 TEST_F(ParserImplTest, HandlesError) {
   auto* p = parser(R"(
-import "GLSL.std.430" as glsl;
-
 fn main() ->  {  # missing return type
   return;
 })");
 
   ASSERT_FALSE(p->Parse());
   ASSERT_TRUE(p->has_error());
-  EXPECT_EQ(p->error(), "4:15: unable to determine function return type");
+  EXPECT_EQ(p->error(), "2:15: unable to determine function return type");
 }
 
 TEST_F(ParserImplTest, GetRegisteredType) {
diff --git a/src/reader/wgsl/parser_test.cc b/src/reader/wgsl/parser_test.cc
index a67751e..363da93 100644
--- a/src/reader/wgsl/parser_test.cc
+++ b/src/reader/wgsl/parser_test.cc
@@ -34,8 +34,6 @@
   Context ctx;
 
   Parser p(&ctx, R"(
-import "GLSL.std.430" as glsl;
-
 [[location(0)]] var<out> gl_FragColor : vec4<f32>;
 
 [[stage(vertex)]]
@@ -46,7 +44,6 @@
   ASSERT_TRUE(p.Parse()) << p.error();
 
   auto m = p.module();
-  ASSERT_EQ(1u, m.imports().size());
   ASSERT_EQ(1u, m.functions().size());
   ASSERT_EQ(1u, m.global_variables().size());
 }
@@ -54,15 +51,13 @@
 TEST_F(ParserTest, HandlesError) {
   Context ctx;
   Parser p(&ctx, R"(
-import "GLSL.std.430" as glsl;
-
 fn main() ->  {  # missing return type
   return;
 })");
 
   ASSERT_FALSE(p.Parse());
   ASSERT_TRUE(p.has_error());
-  EXPECT_EQ(p.error(), "4:15: unable to determine function return type");
+  EXPECT_EQ(p.error(), "2:15: unable to determine function return type");
 }
 
 }  // namespace
diff --git a/src/type_determiner.cc b/src/type_determiner.cc
index 7dbfaf1..0c31e5a 100644
--- a/src/type_determiner.cc
+++ b/src/type_determiner.cc
@@ -17,7 +17,6 @@
 #include <memory>
 #include <vector>
 
-#include "spirv/unified1/GLSL.std.450.h"
 #include "src/ast/array_accessor_expression.h"
 #include "src/ast/as_expression.h"
 #include "src/ast/assignment_statement.h"
@@ -56,104 +55,6 @@
 #include "src/ast/variable_decl_statement.h"
 
 namespace tint {
-namespace {
-
-// Most of these are floating-point general except the below which are only
-// FP16 and FP32. We only have FP32 at this point so the below works, if we
-// get FP64 support or otherwise we'll need to differentiate.
-//   * radians
-//   * degrees
-//   * sin, cos, tan
-//   * asin, acos, atan
-//   * sinh, cosh, tanh
-//   * asinh, acosh, atanh
-//   * exp, exp2
-//   * log, log2
-enum class GlslDataType {
-  kFloatScalarOrVector,
-  kIntScalarOrVector,
-  kFloatVector,
-  kMatrix
-};
-struct GlslData {
-  const char* name;
-  uint8_t param_count;
-  uint32_t op_id;
-  GlslDataType type;
-  uint8_t vector_count;
-};
-
-constexpr const GlslData kGlslData[] = {
-    {"acos", 1, GLSLstd450Acos, GlslDataType::kFloatScalarOrVector, 0},
-    {"acosh", 1, GLSLstd450Acosh, GlslDataType::kFloatScalarOrVector, 0},
-    {"asin", 1, GLSLstd450Asin, GlslDataType::kFloatScalarOrVector, 0},
-    {"asinh", 1, GLSLstd450Asinh, GlslDataType::kFloatScalarOrVector, 0},
-    {"atan", 1, GLSLstd450Atan, GlslDataType::kFloatScalarOrVector, 0},
-    {"atan2", 2, GLSLstd450Atan2, GlslDataType::kFloatScalarOrVector, 0},
-    {"atanh", 1, GLSLstd450Atanh, GlslDataType::kFloatScalarOrVector, 0},
-    {"ceil", 1, GLSLstd450Ceil, GlslDataType::kFloatScalarOrVector, 0},
-    {"cos", 1, GLSLstd450Cos, GlslDataType::kFloatScalarOrVector, 0},
-    {"cosh", 1, GLSLstd450Cosh, GlslDataType::kFloatScalarOrVector, 0},
-    {"cross", 2, GLSLstd450Cross, GlslDataType::kFloatVector, 3},
-    {"degrees", 1, GLSLstd450Degrees, GlslDataType::kFloatScalarOrVector, 0},
-    {"determinant", 1, GLSLstd450Determinant, GlslDataType::kMatrix, 0},
-    {"distance", 2, GLSLstd450Distance, GlslDataType::kFloatScalarOrVector, 0},
-    {"exp", 1, GLSLstd450Exp, GlslDataType::kFloatScalarOrVector, 0},
-    {"exp2", 1, GLSLstd450Exp2, GlslDataType::kFloatScalarOrVector, 0},
-    {"fabs", 1, GLSLstd450FAbs, GlslDataType::kFloatScalarOrVector, 0},
-    {"faceforward", 3, GLSLstd450FaceForward,
-     GlslDataType::kFloatScalarOrVector, 0},
-    {"fclamp", 3, GLSLstd450FClamp, GlslDataType::kFloatScalarOrVector, 0},
-    {"findilsb", 1, GLSLstd450FindILsb, GlslDataType::kIntScalarOrVector, 0},
-    {"findumsb", 1, GLSLstd450FindUMsb, GlslDataType::kIntScalarOrVector, 0},
-    {"findsmsb", 1, GLSLstd450FindSMsb, GlslDataType::kIntScalarOrVector, 0},
-    {"floor", 1, GLSLstd450Floor, GlslDataType::kFloatScalarOrVector, 0},
-    {"fma", 3, GLSLstd450Fma, GlslDataType::kFloatScalarOrVector, 0},
-    {"fmax", 2, GLSLstd450FMax, GlslDataType::kFloatScalarOrVector, 0},
-    {"fmin", 2, GLSLstd450FMin, GlslDataType::kFloatScalarOrVector, 0},
-    {"fmix", 3, GLSLstd450FMix, GlslDataType::kFloatScalarOrVector, 0},
-    {"fract", 1, GLSLstd450Fract, GlslDataType::kFloatScalarOrVector, 0},
-    {"fsign", 1, GLSLstd450FSign, GlslDataType::kFloatScalarOrVector, 0},
-    {"interpolateatcentroid", 1, GLSLstd450InterpolateAtCentroid,
-     GlslDataType::kFloatScalarOrVector, 0},
-    {"inversesqrt", 1, GLSLstd450InverseSqrt,
-     GlslDataType::kFloatScalarOrVector, 0},
-    {"length", 1, GLSLstd450Length, GlslDataType::kFloatScalarOrVector, 0},
-    {"log", 1, GLSLstd450Log, GlslDataType::kFloatScalarOrVector, 0},
-    {"log2", 1, GLSLstd450Log2, GlslDataType::kFloatScalarOrVector, 0},
-    {"matrixinverse", 1, GLSLstd450MatrixInverse, GlslDataType::kMatrix, 0},
-    {"nclamp", 3, GLSLstd450NClamp, GlslDataType::kFloatScalarOrVector, 0},
-    {"nmax", 2, GLSLstd450NMax, GlslDataType::kFloatScalarOrVector, 0},
-    {"nmin", 2, GLSLstd450NMin, GlslDataType::kFloatScalarOrVector, 0},
-    {"normalize", 1, GLSLstd450Normalize, GlslDataType::kFloatScalarOrVector,
-     0},
-    {"pow", 2, GLSLstd450Pow, GlslDataType::kFloatScalarOrVector, 0},
-    {"radians", 1, GLSLstd450Radians, GlslDataType::kFloatScalarOrVector, 0},
-    {"reflect", 2, GLSLstd450Reflect, GlslDataType::kFloatScalarOrVector, 0},
-    {"round", 1, GLSLstd450Round, GlslDataType::kFloatScalarOrVector, 0},
-    {"roundeven", 1, GLSLstd450RoundEven, GlslDataType::kFloatScalarOrVector,
-     0},
-    {"sabs", 1, GLSLstd450SAbs, GlslDataType::kIntScalarOrVector, 0},
-    {"sclamp", 3, GLSLstd450SClamp, GlslDataType::kIntScalarOrVector, 0},
-    {"sin", 1, GLSLstd450Sin, GlslDataType::kFloatScalarOrVector, 0},
-    {"sinh", 1, GLSLstd450Sinh, GlslDataType::kFloatScalarOrVector, 0},
-    {"smax", 2, GLSLstd450SMax, GlslDataType::kIntScalarOrVector, 0},
-    {"smin", 2, GLSLstd450SMin, GlslDataType::kIntScalarOrVector, 0},
-    {"smoothstep", 3, GLSLstd450SmoothStep, GlslDataType::kFloatScalarOrVector,
-     0},
-    {"sqrt", 1, GLSLstd450Sqrt, GlslDataType::kFloatScalarOrVector, 0},
-    {"ssign", 1, GLSLstd450SSign, GlslDataType::kIntScalarOrVector, 0},
-    {"step", 2, GLSLstd450Step, GlslDataType::kFloatScalarOrVector, 0},
-    {"tan", 1, GLSLstd450Tan, GlslDataType::kFloatScalarOrVector, 0},
-    {"tanh", 1, GLSLstd450Tanh, GlslDataType::kFloatScalarOrVector, 0},
-    {"trunc", 1, GLSLstd450Trunc, GlslDataType::kFloatScalarOrVector, 0},
-    {"uclamp", 3, GLSLstd450UClamp, GlslDataType::kIntScalarOrVector, 0},
-    {"umax", 2, GLSLstd450UMax, GlslDataType::kIntScalarOrVector, 0},
-    {"umin", 2, GLSLstd450UMin, GlslDataType::kIntScalarOrVector, 0},
-};
-constexpr const uint32_t kGlslDataCount = sizeof(kGlslData) / sizeof(GlslData);
-
-}  // namespace
 
 TypeDeterminer::TypeDeterminer(Context* ctx, ast::Module* mod)
     : ctx_(*ctx), mod_(mod) {}
@@ -471,6 +372,9 @@
 }
 
 bool TypeDeterminer::DetermineCall(ast::CallExpression* expr) {
+  if (!DetermineResultType(expr->func())) {
+    return false;
+  }
   if (!DetermineResultType(expr->params())) {
     return false;
   }
@@ -481,31 +385,10 @@
   if (expr->func()->IsIdentifier()) {
     auto* ident = expr->func()->AsIdentifier();
 
-    if (ast::intrinsic::IsIntrinsic(ident->name())) {
-      if (!DetermineIntrinsic(ident->name(), expr))
-        return false;
-
-    } else if (ident->has_path()) {
-      auto* imp = mod_->FindImportByName(ident->path());
-      if (imp == nullptr) {
-        set_error(expr->source(), "Unable to find import for " + ident->name());
+    if (ident->IsIntrinsic()) {
+      if (!DetermineIntrinsic(ident, expr)) {
         return false;
       }
-
-      uint32_t ext_id = 0;
-      auto* result_type = GetImportData(expr->source(), imp->path(),
-                                        ident->name(), expr->params(), &ext_id);
-      if (result_type == nullptr) {
-        if (error_.empty()) {
-          set_error(expr->source(),
-                    "Unable to determine result type for GLSL expression " +
-                        ident->name());
-        }
-        return false;
-      }
-
-      imp->AddMethodId(ident->name(), ext_id);
-      expr->func()->set_result_type(result_type);
     } else {
       if (current_function_) {
         caller_to_callee_[current_function_->name()].push_back(ident->name());
@@ -547,41 +430,111 @@
   return true;
 }
 
-bool TypeDeterminer::DetermineIntrinsic(const std::string& name,
+namespace {
+
+enum class IntrinsicDataType {
+  kFloatOrIntScalarOrVector,
+  kFloatScalarOrVector,
+  kIntScalarOrVector,
+  kFloatVector,
+  kMatrix,
+};
+struct IntrinsicData {
+  ast::Intrinsic intrinsic;
+  uint8_t param_count;
+  IntrinsicDataType data_type;
+  uint8_t vector_size;
+};
+
+// Note, this isn't all the intrinsics. Some are handled specially before
+// we get to the generic code. See the DetermineIntrinsic code below.
+constexpr const IntrinsicData kIntrinsicData[] = {
+    {ast::Intrinsic::kAbs, 1, IntrinsicDataType::kFloatOrIntScalarOrVector, 0},
+    {ast::Intrinsic::kAcos, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kAsin, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kAtan, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kAtan2, 2, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kCeil, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kClamp, 3, IntrinsicDataType::kFloatOrIntScalarOrVector,
+     0},
+    {ast::Intrinsic::kCos, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kCosh, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kCountOneBits, 1, IntrinsicDataType::kIntScalarOrVector,
+     0},
+    {ast::Intrinsic::kCross, 2, IntrinsicDataType::kFloatVector, 3},
+    {ast::Intrinsic::kDeterminant, 1, IntrinsicDataType::kMatrix, 0},
+    {ast::Intrinsic::kDistance, 2, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kExp, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kExp2, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kFaceForward, 3, IntrinsicDataType::kFloatScalarOrVector,
+     0},
+    {ast::Intrinsic::kFloor, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kFma, 3, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kFract, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kFrexp, 2, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kInverseSqrt, 1, IntrinsicDataType::kFloatScalarOrVector,
+     0},
+    {ast::Intrinsic::kLdexp, 2, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kLength, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kLog, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kLog2, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kMax, 2, IntrinsicDataType::kFloatOrIntScalarOrVector, 0},
+    {ast::Intrinsic::kMin, 2, IntrinsicDataType::kFloatOrIntScalarOrVector, 0},
+    {ast::Intrinsic::kMix, 3, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kModf, 2, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kNormalize, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kPow, 2, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kReflect, 2, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kReverseBits, 1, IntrinsicDataType::kIntScalarOrVector, 0},
+    {ast::Intrinsic::kRound, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kSign, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kSin, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kSinh, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kSmoothStep, 3, IntrinsicDataType::kFloatScalarOrVector,
+     0},
+    {ast::Intrinsic::kSqrt, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kStep, 2, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kTan, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kTanh, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+    {ast::Intrinsic::kTrunc, 1, IntrinsicDataType::kFloatScalarOrVector, 0},
+};
+
+constexpr const uint32_t kIntrinsicDataCount =
+    sizeof(kIntrinsicData) / sizeof(IntrinsicData);
+
+}  // namespace
+
+bool TypeDeterminer::DetermineIntrinsic(ast::IdentifierExpression* ident,
                                         ast::CallExpression* expr) {
-  if (ast::intrinsic::IsDerivative(name)) {
+  if (ast::intrinsic::IsDerivative(ident->intrinsic())) {
     if (expr->params().size() != 1) {
-      set_error(expr->source(), "incorrect number of parameters for " + name);
+      set_error(expr->source(),
+                "incorrect number of parameters for " + ident->name());
       return false;
     }
 
     // The result type must be the same as the type of the parameter.
-    auto& param = expr->params()[0];
-    if (!DetermineResultType(param.get())) {
-      return false;
-    }
-    expr->func()->set_result_type(param->result_type()->UnwrapPtrIfNeeded());
+    auto* param_type = expr->params()[0]->result_type()->UnwrapPtrIfNeeded();
+    expr->func()->set_result_type(param_type);
     return true;
   }
-  if (name == "any" || name == "all") {
+  if (ident->intrinsic() == ast::Intrinsic::kAny ||
+      ident->intrinsic() == ast::Intrinsic::kAll) {
     expr->func()->set_result_type(
         ctx_.type_mgr().Get(std::make_unique<ast::type::BoolType>()));
     return true;
   }
-  if (ast::intrinsic::IsFloatClassificationIntrinsic(name)) {
+  if (ast::intrinsic::IsFloatClassificationIntrinsic(ident->intrinsic())) {
     if (expr->params().size() != 1) {
-      set_error(expr->source(), "incorrect number of parameters for " + name);
+      set_error(expr->source(),
+                "incorrect number of parameters for " + ident->name());
       return false;
     }
 
     auto* bool_type =
         ctx_.type_mgr().Get(std::make_unique<ast::type::BoolType>());
 
-    auto& param = expr->params()[0];
-    if (!DetermineResultType(param.get())) {
-      return false;
-    }
-    auto* param_type = param->result_type()->UnwrapPtrIfNeeded();
+    auto* param_type = expr->params()[0]->result_type()->UnwrapPtrIfNeeded();
     if (param_type->IsVector()) {
       expr->func()->set_result_type(
           ctx_.type_mgr().Get(std::make_unique<ast::type::VectorType>(
@@ -591,31 +544,31 @@
     }
     return true;
   }
-  if (ast::intrinsic::IsTextureOperationIntrinsic(name)) {
+  if (ast::intrinsic::IsTextureIntrinsic(ident->intrinsic())) {
     // TODO: Remove the LOD param from textureLoad on storage textures when
     // https://github.com/gpuweb/gpuweb/pull/1032 gets merged.
     uint32_t num_of_params =
-        (name == "textureLoad" || name == "textureSample") ? 3 : 4;
+        (ident->intrinsic() == ast::Intrinsic::kTextureLoad ||
+         ident->intrinsic() == ast::Intrinsic::kTextureSample)
+            ? 3
+            : 4;
     if (expr->params().size() != num_of_params) {
       set_error(expr->source(),
-                "incorrect number of parameters for " + name + ", got " +
-                    std::to_string(expr->params().size()) + " and expected " +
-                    std::to_string(num_of_params));
+                "incorrect number of parameters for " + ident->name() +
+                    ", got " + std::to_string(expr->params().size()) +
+                    " and expected " + std::to_string(num_of_params));
       return false;
     }
 
-    if (name == "textureSampleCompare") {
+    if (ident->intrinsic() == ast::Intrinsic::kTextureSampleCompare) {
       expr->func()->set_result_type(
           ctx_.type_mgr().Get(std::make_unique<ast::type::F32Type>()));
       return true;
     }
 
     auto& texture_param = expr->params()[0];
-    if (!DetermineResultType(texture_param.get())) {
-      return false;
-    }
     if (!texture_param->result_type()->UnwrapPtrIfNeeded()->IsTexture()) {
-      set_error(expr->source(), "invalid first argument for " + name);
+      set_error(expr->source(), "invalid first argument for " + ident->name());
       return false;
     }
     ast::type::TextureType* texture =
@@ -623,7 +576,7 @@
 
     if (!texture->IsStorage() &&
         !(texture->IsSampled() || texture->IsMultisampled())) {
-      set_error(expr->source(), "invalid texture for " + name);
+      set_error(expr->source(), "invalid texture for " + ident->name());
       return false;
     }
 
@@ -642,29 +595,22 @@
         ctx_.type_mgr().Get(std::make_unique<ast::type::VectorType>(type, 4)));
     return true;
   }
-  if (name == "dot") {
+  if (ident->intrinsic() == ast::Intrinsic::kDot) {
     expr->func()->set_result_type(
         ctx_.type_mgr().Get(std::make_unique<ast::type::F32Type>()));
     return true;
   }
-  if (name == "outerProduct") {
+  if (ident->intrinsic() == ast::Intrinsic::kOuterProduct) {
     if (expr->params().size() != 2) {
       set_error(expr->source(),
-                "incorrect number of parameters for outer_product");
+                "incorrect number of parameters for " + ident->name());
       return false;
     }
 
-    auto& param0 = expr->params()[0];
-    auto& param1 = expr->params()[1];
-    if (!DetermineResultType(param0.get()) ||
-        !DetermineResultType(param1.get())) {
-      return false;
-    }
-
-    auto* param0_type = param0->result_type()->UnwrapPtrIfNeeded();
-    auto* param1_type = param1->result_type()->UnwrapPtrIfNeeded();
+    auto* param0_type = expr->params()[0]->result_type()->UnwrapPtrIfNeeded();
+    auto* param1_type = expr->params()[1]->result_type()->UnwrapPtrIfNeeded();
     if (!param0_type->IsVector() || !param1_type->IsVector()) {
-      set_error(expr->source(), "invalid parameter type for outer_product");
+      set_error(expr->source(), "invalid parameter type for " + ident->name());
       return false;
     }
 
@@ -674,24 +620,121 @@
             param0_type->AsVector()->size(), param1_type->AsVector()->size())));
     return true;
   }
-  if (name == "select") {
+  if (ident->intrinsic() == ast::Intrinsic::kSelect) {
     if (expr->params().size() != 3) {
-      set_error(expr->source(),
-                "incorrect number of parameters for select expected 3 got " +
-                    std::to_string(expr->params().size()));
+      set_error(expr->source(), "incorrect number of parameters for " +
+                                    ident->name() + " expected 3 got " +
+                                    std::to_string(expr->params().size()));
       return false;
     }
 
     // The result type must be the same as the type of the parameter.
-    auto& param = expr->params()[0];
-    if (!DetermineResultType(param.get())) {
-      return false;
-    }
-    expr->func()->set_result_type(param->result_type()->UnwrapPtrIfNeeded());
+    auto* param_type = expr->params()[0]->result_type()->UnwrapPtrIfNeeded();
+    expr->func()->set_result_type(param_type);
     return true;
   }
 
-  return false;
+  const IntrinsicData* data = nullptr;
+  for (uint32_t i = 0; i < kIntrinsicDataCount; ++i) {
+    if (ident->intrinsic() == kIntrinsicData[i].intrinsic) {
+      data = &kIntrinsicData[i];
+      break;
+    }
+  }
+  if (data == nullptr) {
+    return false;
+  }
+
+  if (expr->params().size() != data->param_count) {
+    set_error(expr->source(), "incorrect number of parameters for " +
+                                  ident->name() + ". Expected " +
+                                  std::to_string(data->param_count) + " got " +
+                                  std::to_string(expr->params().size()));
+    return false;
+  }
+
+  std::vector<ast::type::Type*> result_types;
+  for (uint32_t i = 0; i < data->param_count; ++i) {
+    result_types.push_back(
+        expr->params()[i]->result_type()->UnwrapPtrIfNeeded());
+
+    switch (data->data_type) {
+      case IntrinsicDataType::kFloatOrIntScalarOrVector:
+        if (!result_types.back()->is_float_scalar_or_vector() &&
+            !result_types.back()->is_integer_scalar_or_vector()) {
+          set_error(expr->source(),
+                    "incorrect type for " + ident->name() + ". " +
+                        "Requires float or int, scalar or vector values");
+          return false;
+        }
+        break;
+      case IntrinsicDataType::kFloatScalarOrVector:
+        if (!result_types.back()->is_float_scalar_or_vector()) {
+          set_error(expr->source(),
+                    "incorrect type for " + ident->name() + ". " +
+                        "Requires float scalar or float vector values");
+          return false;
+        }
+
+        break;
+      case IntrinsicDataType::kIntScalarOrVector:
+        if (!result_types.back()->is_integer_scalar_or_vector()) {
+          set_error(expr->source(),
+                    "incorrect type for " + ident->name() + ". " +
+                        "Requires integer scalar or integer vector values");
+          return false;
+        }
+        break;
+      case IntrinsicDataType::kFloatVector:
+        if (!result_types.back()->is_float_vector()) {
+          set_error(expr->source(), "incorrect type for " + ident->name() +
+                                        ". " + "Requires float vector values");
+          return false;
+        }
+        if (data->vector_size > 0 &&
+            result_types.back()->AsVector()->size() != data->vector_size) {
+          set_error(expr->source(), "incorrect vector size for " +
+                                        ident->name() + ". " + "Requires " +
+                                        std::to_string(data->vector_size) +
+                                        " elements");
+          return false;
+        }
+        break;
+      case IntrinsicDataType::kMatrix:
+        if (!result_types.back()->IsMatrix()) {
+          set_error(expr->source(), "incorrect type for " + ident->name() +
+                                        ". Requires matrix value");
+          return false;
+        }
+        break;
+    }
+  }
+
+  // Verify all the parameter types match
+  for (size_t i = 1; i < data->param_count; ++i) {
+    if (result_types[0] != result_types[i]) {
+      set_error(expr->source(),
+                "mismatched parameter types for " + ident->name());
+      return false;
+    }
+  }
+
+  // Handle functions which aways return the type, even if a vector is
+  // provided.
+  if (ident->intrinsic() == ast::Intrinsic::kLength ||
+      ident->intrinsic() == ast::Intrinsic::kDistance) {
+    expr->func()->set_result_type(result_types[0]->is_float_scalar()
+                                      ? result_types[0]
+                                      : result_types[0]->AsVector()->type());
+    return true;
+  }
+  // The determinant returns the component type of the columns
+  if (ident->intrinsic() == ast::Intrinsic::kDeterminant) {
+    expr->func()->set_result_type(result_types[0]->AsMatrix()->type());
+    return true;
+  }
+  expr->func()->set_result_type(result_types[0]);
+  return true;
 }
 
 bool TypeDeterminer::DetermineCast(ast::CastExpression* expr) {
@@ -719,12 +762,6 @@
 }
 
 bool TypeDeterminer::DetermineIdentifier(ast::IdentifierExpression* expr) {
-  if (expr->has_path()) {
-    set_error(expr->source(),
-              "determine identifier should not be called with imports");
-    return false;
-  }
-
   auto name = expr->name();
   ast::Variable* var;
   if (variable_stack_.get(name, &var)) {
@@ -750,9 +787,147 @@
     return true;
   }
 
+  SetIntrinsicIfNeeded(expr);
+
   return true;
 }
 
+void TypeDeterminer::SetIntrinsicIfNeeded(ast::IdentifierExpression* ident) {
+  if (ident->name() == "abs") {
+    ident->set_intrinsic(ast::Intrinsic::kAbs);
+  } else if (ident->name() == "acos") {
+    ident->set_intrinsic(ast::Intrinsic::kAcos);
+  } else if (ident->name() == "all") {
+    ident->set_intrinsic(ast::Intrinsic::kAll);
+  } else if (ident->name() == "any") {
+    ident->set_intrinsic(ast::Intrinsic::kAny);
+  } else if (ident->name() == "asin") {
+    ident->set_intrinsic(ast::Intrinsic::kAsin);
+  } else if (ident->name() == "atan") {
+    ident->set_intrinsic(ast::Intrinsic::kAtan);
+  } else if (ident->name() == "atan2") {
+    ident->set_intrinsic(ast::Intrinsic::kAtan2);
+  } else if (ident->name() == "ceil") {
+    ident->set_intrinsic(ast::Intrinsic::kCeil);
+  } else if (ident->name() == "clamp") {
+    ident->set_intrinsic(ast::Intrinsic::kClamp);
+  } else if (ident->name() == "cos") {
+    ident->set_intrinsic(ast::Intrinsic::kCos);
+  } else if (ident->name() == "cosh") {
+    ident->set_intrinsic(ast::Intrinsic::kCosh);
+  } else if (ident->name() == "countOneBits") {
+    ident->set_intrinsic(ast::Intrinsic::kCountOneBits);
+  } else if (ident->name() == "cross") {
+    ident->set_intrinsic(ast::Intrinsic::kCross);
+  } else if (ident->name() == "determinant") {
+    ident->set_intrinsic(ast::Intrinsic::kDeterminant);
+  } else if (ident->name() == "distance") {
+    ident->set_intrinsic(ast::Intrinsic::kDistance);
+  } else if (ident->name() == "dot") {
+    ident->set_intrinsic(ast::Intrinsic::kDot);
+  } else if (ident->name() == "dpdx") {
+    ident->set_intrinsic(ast::Intrinsic::kDpdx);
+  } else if (ident->name() == "dpdxCoarse") {
+    ident->set_intrinsic(ast::Intrinsic::kDpdxCoarse);
+  } else if (ident->name() == "dpdxFine") {
+    ident->set_intrinsic(ast::Intrinsic::kDpdxFine);
+  } else if (ident->name() == "dpdy") {
+    ident->set_intrinsic(ast::Intrinsic::kDpdy);
+  } else if (ident->name() == "dpdyCoarse") {
+    ident->set_intrinsic(ast::Intrinsic::kDpdyCoarse);
+  } else if (ident->name() == "dpdyFine") {
+    ident->set_intrinsic(ast::Intrinsic::kDpdyFine);
+  } else if (ident->name() == "exp") {
+    ident->set_intrinsic(ast::Intrinsic::kExp);
+  } else if (ident->name() == "exp2") {
+    ident->set_intrinsic(ast::Intrinsic::kExp2);
+  } else if (ident->name() == "faceForward") {
+    ident->set_intrinsic(ast::Intrinsic::kFaceForward);
+  } else if (ident->name() == "floor") {
+    ident->set_intrinsic(ast::Intrinsic::kFloor);
+  } else if (ident->name() == "fma") {
+    ident->set_intrinsic(ast::Intrinsic::kFma);
+  } else if (ident->name() == "fract") {
+    ident->set_intrinsic(ast::Intrinsic::kFract);
+  } else if (ident->name() == "frexp") {
+    ident->set_intrinsic(ast::Intrinsic::kFrexp);
+  } else if (ident->name() == "fwidth") {
+    ident->set_intrinsic(ast::Intrinsic::kFwidth);
+  } else if (ident->name() == "fwidthCoarse") {
+    ident->set_intrinsic(ast::Intrinsic::kFwidthCoarse);
+  } else if (ident->name() == "fwidthFine") {
+    ident->set_intrinsic(ast::Intrinsic::kFwidthFine);
+  } else if (ident->name() == "inverseSqrt") {
+    ident->set_intrinsic(ast::Intrinsic::kInverseSqrt);
+  } else if (ident->name() == "isFinite") {
+    ident->set_intrinsic(ast::Intrinsic::kIsFinite);
+  } else if (ident->name() == "isInf") {
+    ident->set_intrinsic(ast::Intrinsic::kIsInf);
+  } else if (ident->name() == "isNan") {
+    ident->set_intrinsic(ast::Intrinsic::kIsNan);
+  } else if (ident->name() == "isNormal") {
+    ident->set_intrinsic(ast::Intrinsic::kIsNormal);
+  } else if (ident->name() == "ldexp") {
+    ident->set_intrinsic(ast::Intrinsic::kLdexp);
+  } else if (ident->name() == "length") {
+    ident->set_intrinsic(ast::Intrinsic::kLength);
+  } else if (ident->name() == "log") {
+    ident->set_intrinsic(ast::Intrinsic::kLog);
+  } else if (ident->name() == "log2") {
+    ident->set_intrinsic(ast::Intrinsic::kLog2);
+  } else if (ident->name() == "max") {
+    ident->set_intrinsic(ast::Intrinsic::kMax);
+  } else if (ident->name() == "min") {
+    ident->set_intrinsic(ast::Intrinsic::kMin);
+  } else if (ident->name() == "mix") {
+    ident->set_intrinsic(ast::Intrinsic::kMix);
+  } else if (ident->name() == "modf") {
+    ident->set_intrinsic(ast::Intrinsic::kModf);
+  } else if (ident->name() == "normalize") {
+    ident->set_intrinsic(ast::Intrinsic::kNormalize);
+  } else if (ident->name() == "outerProduct") {
+    ident->set_intrinsic(ast::Intrinsic::kOuterProduct);
+  } else if (ident->name() == "pow") {
+    ident->set_intrinsic(ast::Intrinsic::kPow);
+  } else if (ident->name() == "reflect") {
+    ident->set_intrinsic(ast::Intrinsic::kReflect);
+  } else if (ident->name() == "reverseBits") {
+    ident->set_intrinsic(ast::Intrinsic::kReverseBits);
+  } else if (ident->name() == "round") {
+    ident->set_intrinsic(ast::Intrinsic::kRound);
+  } else if (ident->name() == "select") {
+    ident->set_intrinsic(ast::Intrinsic::kSelect);
+  } else if (ident->name() == "sign") {
+    ident->set_intrinsic(ast::Intrinsic::kSign);
+  } else if (ident->name() == "sin") {
+    ident->set_intrinsic(ast::Intrinsic::kSin);
+  } else if (ident->name() == "sinh") {
+    ident->set_intrinsic(ast::Intrinsic::kSinh);
+  } else if (ident->name() == "smoothStep") {
+    ident->set_intrinsic(ast::Intrinsic::kSmoothStep);
+  } else if (ident->name() == "sqrt") {
+    ident->set_intrinsic(ast::Intrinsic::kSqrt);
+  } else if (ident->name() == "step") {
+    ident->set_intrinsic(ast::Intrinsic::kStep);
+  } else if (ident->name() == "tan") {
+    ident->set_intrinsic(ast::Intrinsic::kTan);
+  } else if (ident->name() == "tanh") {
+    ident->set_intrinsic(ast::Intrinsic::kTanh);
+  } else if (ident->name() == "textureLoad") {
+    ident->set_intrinsic(ast::Intrinsic::kTextureLoad);
+  } else if (ident->name() == "textureSample") {
+    ident->set_intrinsic(ast::Intrinsic::kTextureSample);
+  } else if (ident->name() == "textureSampleBias") {
+    ident->set_intrinsic(ast::Intrinsic::kTextureSampleBias);
+  } else if (ident->name() == "textureSampleCompare") {
+    ident->set_intrinsic(ast::Intrinsic::kTextureSampleCompare);
+  } else if (ident->name() == "textureSampleLevel") {
+    ident->set_intrinsic(ast::Intrinsic::kTextureSampleLevel);
+  } else if (ident->name() == "trunc") {
+    ident->set_intrinsic(ast::Intrinsic::kTrunc);
+  }
+}
+
 bool TypeDeterminer::DetermineMemberAccessor(
     ast::MemberAccessorExpression* expr) {
   if (!DetermineResultType(expr->structure())) {
@@ -962,101 +1137,4 @@
   return false;
 }
 
-ast::type::Type* TypeDeterminer::GetImportData(
-    const Source& source,
-    const std::string& path,
-    const std::string& name,
-    const ast::ExpressionList& params,
-    uint32_t* id) {
-  if (path != "GLSL.std.450") {
-    set_error(source, "unknown import path " + path);
-    return nullptr;
-  }
-
-  const GlslData* data = nullptr;
-  for (uint32_t i = 0; i < kGlslDataCount; ++i) {
-    if (name == kGlslData[i].name) {
-      data = &kGlslData[i];
-      break;
-    }
-  }
-  if (data == nullptr) {
-    return nullptr;
-  }
-
-  if (params.size() != data->param_count) {
-    set_error(source, "incorrect number of parameters for " + name +
-                          ". Expected " + std::to_string(data->param_count) +
-                          " got " + std::to_string(params.size()));
-    return nullptr;
-  }
-
-  std::vector<ast::type::Type*> result_types;
-  for (uint32_t i = 0; i < data->param_count; ++i) {
-    result_types.push_back(params[i]->result_type()->UnwrapPtrIfNeeded());
-
-    switch (data->type) {
-      case GlslDataType::kFloatScalarOrVector:
-        if (!result_types.back()->is_float_scalar_or_vector()) {
-          set_error(source, "incorrect type for " + name + ". " +
-                                "Requires float scalar or float vector values");
-          return nullptr;
-        }
-
-        break;
-      case GlslDataType::kIntScalarOrVector:
-        if (!result_types.back()->is_integer_scalar_or_vector()) {
-          set_error(source,
-                    "incorrect type for " + name + ". " +
-                        "Requires integer scalar or integer vector values");
-          return nullptr;
-        }
-        break;
-      case GlslDataType::kFloatVector:
-        if (!result_types.back()->is_float_vector()) {
-          set_error(source, "incorrect type for " + name + ". " +
-                                "Requires float vector values");
-          return nullptr;
-        }
-        if (data->vector_count > 0 &&
-            result_types.back()->AsVector()->size() != data->vector_count) {
-          set_error(source,
-                    "incorrect vector size for " + name + ". " + "Requires " +
-                        std::to_string(data->vector_count) + " elements");
-          return nullptr;
-        }
-        break;
-      case GlslDataType::kMatrix:
-        if (!result_types.back()->IsMatrix()) {
-          set_error(source,
-                    "incorrect type for " + name + ". Requires matrix value");
-          return nullptr;
-        }
-        break;
-    }
-  }
-
-  // Verify all the parameter types match
-  for (size_t i = 1; i < data->param_count; ++i) {
-    if (result_types[0] != result_types[i]) {
-      error_ = "mismatched parameter types for " + name;
-      return nullptr;
-    }
-  }
-
-  *id = data->op_id;
-
-  // Handle functions which aways return the type, even if a vector is provided.
-  if (name == "length" || name == "distance") {
-    return result_types[0]->is_float_scalar()
-               ? result_types[0]
-               : result_types[0]->AsVector()->type();
-  }
-  // The determinant returns the component type of the columns
-  if (name == "determinant") {
-    return result_types[0]->AsMatrix()->type();
-  }
-  return result_types[0];
-}
-
 }  // namespace tint
diff --git a/src/type_determiner.h b/src/type_determiner.h
index d094259..a7b689d 100644
--- a/src/type_determiner.h
+++ b/src/type_determiner.h
@@ -107,6 +107,10 @@
                                  const ast::ExpressionList& params,
                                  uint32_t* id);
 
+  /// Sets the intrinsic data information for the identifier if needed
+  /// @param ident the identifier expression
+  void SetIntrinsicIfNeeded(ast::IdentifierExpression* ident);
+
  private:
   void set_error(const Source& src, const std::string& msg);
   void set_referenced_from_function_if_needed(ast::Variable* var);
@@ -119,7 +123,8 @@
   bool DetermineCast(ast::CastExpression* expr);
   bool DetermineConstructor(ast::ConstructorExpression* expr);
   bool DetermineIdentifier(ast::IdentifierExpression* expr);
-  bool DetermineIntrinsic(const std::string& name, ast::CallExpression* expr);
+  bool DetermineIntrinsic(ast::IdentifierExpression* name,
+                          ast::CallExpression* expr);
   bool DetermineMemberAccessor(ast::MemberAccessorExpression* expr);
   bool DetermineUnaryOp(ast::UnaryOpExpression* expr);
 
diff --git a/src/type_determiner_test.cc b/src/type_determiner_test.cc
index f2ce9d6..21c29d4 100644
--- a/src/type_determiner_test.cc
+++ b/src/type_determiner_test.cc
@@ -19,12 +19,12 @@
 #include <vector>
 
 #include "gtest/gtest.h"
-#include "spirv/unified1/GLSL.std.450.h"
 #include "src/ast/array_accessor_expression.h"
 #include "src/ast/as_expression.h"
 #include "src/ast/assignment_statement.h"
 #include "src/ast/binary_expression.h"
 #include "src/ast/block_statement.h"
+#include "src/ast/bool_literal.h"
 #include "src/ast/break_statement.h"
 #include "src/ast/call_expression.h"
 #include "src/ast/call_statement.h"
@@ -666,11 +666,9 @@
   EXPECT_TRUE(param_ptr->result_type()->IsF32());
 }
 
-TEST_F(TypeDeterminerTest, Expr_Call_GLSLImport) {
+TEST_F(TypeDeterminerTest, Expr_Call_Intrinsic) {
   ast::type::F32Type f32;
 
-  mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
-
   // Register the function
   EXPECT_TRUE(td()->Determine());
 
@@ -678,8 +676,7 @@
   call_params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 2.4)));
 
-  std::vector<std::string> name{"std", "round"};
-  ast::CallExpression call(std::make_unique<ast::IdentifierExpression>(name),
+  ast::CallExpression call(std::make_unique<ast::IdentifierExpression>("round"),
                            std::move(call_params));
 
   EXPECT_TRUE(td()->DetermineResultType(&call));
@@ -2351,7 +2348,7 @@
   // Register the variable
   EXPECT_TRUE(td()->Determine());
   EXPECT_FALSE(td()->DetermineResultType(&expr));
-  EXPECT_EQ(td()->error(), "incorrect number of parameters for outer_product");
+  EXPECT_EQ(td()->error(), "incorrect number of parameters for outerProduct");
 }
 
 TEST_F(TypeDeterminerTest, Intrinsic_OuterProduct_TooManyParams) {
@@ -2375,7 +2372,7 @@
   // Register the variable
   EXPECT_TRUE(td()->Determine());
   EXPECT_FALSE(td()->DetermineResultType(&expr));
-  EXPECT_EQ(td()->error(), "incorrect number of parameters for outer_product");
+  EXPECT_EQ(td()->error(), "incorrect number of parameters for outerProduct");
 }
 
 using UnaryOpExpressionTest = TypeDeterminerTestWithParam<ast::UnaryOp>;
@@ -2470,16 +2467,104 @@
             "function variable has a non-function storage class");
 }
 
-struct GLSLData {
+struct IntrinsicData {
   const char* name;
-  uint32_t value;
+  ast::Intrinsic intrinsic;
 };
-inline std::ostream& operator<<(std::ostream& out, GLSLData data) {
+inline std::ostream& operator<<(std::ostream& out, IntrinsicData data) {
   out << data.name;
   return out;
 }
-using ImportData_SingleParamTest = TypeDeterminerTestWithParam<GLSLData>;
+using IntrinsicDataTest = TypeDeterminerTestWithParam<IntrinsicData>;
+TEST_P(IntrinsicDataTest, Lookup) {
+  auto param = GetParam();
 
+  ast::IdentifierExpression ident(param.name);
+  td()->SetIntrinsicIfNeeded(&ident);
+  EXPECT_EQ(ident.intrinsic(), param.intrinsic);
+  EXPECT_TRUE(ident.IsIntrinsic());
+}
+INSTANTIATE_TEST_SUITE_P(
+    TypeDeterminerTest,
+    IntrinsicDataTest,
+    testing::Values(
+        IntrinsicData{"abs", ast::Intrinsic::kAbs},
+        IntrinsicData{"acos", ast::Intrinsic::kAcos},
+        IntrinsicData{"all", ast::Intrinsic::kAll},
+        IntrinsicData{"any", ast::Intrinsic::kAny},
+        IntrinsicData{"asin", ast::Intrinsic::kAsin},
+        IntrinsicData{"atan", ast::Intrinsic::kAtan},
+        IntrinsicData{"atan2", ast::Intrinsic::kAtan2},
+        IntrinsicData{"ceil", ast::Intrinsic::kCeil},
+        IntrinsicData{"clamp", ast::Intrinsic::kClamp},
+        IntrinsicData{"cos", ast::Intrinsic::kCos},
+        IntrinsicData{"cosh", ast::Intrinsic::kCosh},
+        IntrinsicData{"countOneBits", ast::Intrinsic::kCountOneBits},
+        IntrinsicData{"cross", ast::Intrinsic::kCross},
+        IntrinsicData{"determinant", ast::Intrinsic::kDeterminant},
+        IntrinsicData{"distance", ast::Intrinsic::kDistance},
+        IntrinsicData{"dot", ast::Intrinsic::kDot},
+        IntrinsicData{"dpdx", ast::Intrinsic::kDpdx},
+        IntrinsicData{"dpdxCoarse", ast::Intrinsic::kDpdxCoarse},
+        IntrinsicData{"dpdxFine", ast::Intrinsic::kDpdxFine},
+        IntrinsicData{"dpdy", ast::Intrinsic::kDpdy},
+        IntrinsicData{"dpdyCoarse", ast::Intrinsic::kDpdyCoarse},
+        IntrinsicData{"dpdyFine", ast::Intrinsic::kDpdyFine},
+        IntrinsicData{"exp", ast::Intrinsic::kExp},
+        IntrinsicData{"exp2", ast::Intrinsic::kExp2},
+        IntrinsicData{"faceForward", ast::Intrinsic::kFaceForward},
+        IntrinsicData{"floor", ast::Intrinsic::kFloor},
+        IntrinsicData{"fma", ast::Intrinsic::kFma},
+        IntrinsicData{"fract", ast::Intrinsic::kFract},
+        IntrinsicData{"frexp", ast::Intrinsic::kFrexp},
+        IntrinsicData{"fwidth", ast::Intrinsic::kFwidth},
+        IntrinsicData{"fwidthCoarse", ast::Intrinsic::kFwidthCoarse},
+        IntrinsicData{"fwidthFine", ast::Intrinsic::kFwidthFine},
+        IntrinsicData{"inverseSqrt", ast::Intrinsic::kInverseSqrt},
+        IntrinsicData{"isFinite", ast::Intrinsic::kIsFinite},
+        IntrinsicData{"isInf", ast::Intrinsic::kIsInf},
+        IntrinsicData{"isNan", ast::Intrinsic::kIsNan},
+        IntrinsicData{"isNormal", ast::Intrinsic::kIsNormal},
+        IntrinsicData{"ldexp", ast::Intrinsic::kLdexp},
+        IntrinsicData{"length", ast::Intrinsic::kLength},
+        IntrinsicData{"log", ast::Intrinsic::kLog},
+        IntrinsicData{"log2", ast::Intrinsic::kLog2},
+        IntrinsicData{"max", ast::Intrinsic::kMax},
+        IntrinsicData{"min", ast::Intrinsic::kMin},
+        IntrinsicData{"mix", ast::Intrinsic::kMix},
+        IntrinsicData{"modf", ast::Intrinsic::kModf},
+        IntrinsicData{"normalize", ast::Intrinsic::kNormalize},
+        IntrinsicData{"outerProduct", ast::Intrinsic::kOuterProduct},
+        IntrinsicData{"pow", ast::Intrinsic::kPow},
+        IntrinsicData{"reflect", ast::Intrinsic::kReflect},
+        IntrinsicData{"reverseBits", ast::Intrinsic::kReverseBits},
+        IntrinsicData{"round", ast::Intrinsic::kRound},
+        IntrinsicData{"select", ast::Intrinsic::kSelect},
+        IntrinsicData{"sign", ast::Intrinsic::kSign},
+        IntrinsicData{"sin", ast::Intrinsic::kSin},
+        IntrinsicData{"sinh", ast::Intrinsic::kSinh},
+        IntrinsicData{"smoothStep", ast::Intrinsic::kSmoothStep},
+        IntrinsicData{"sqrt", ast::Intrinsic::kSqrt},
+        IntrinsicData{"step", ast::Intrinsic::kStep},
+        IntrinsicData{"tan", ast::Intrinsic::kTan},
+        IntrinsicData{"tanh", ast::Intrinsic::kTanh},
+        IntrinsicData{"textureLoad", ast::Intrinsic::kTextureLoad},
+        IntrinsicData{"textureSample", ast::Intrinsic::kTextureSample},
+        IntrinsicData{"textureSampleBias", ast::Intrinsic::kTextureSampleBias},
+        IntrinsicData{"textureSampleCompare",
+                      ast::Intrinsic::kTextureSampleCompare},
+        IntrinsicData{"textureSampleLevel",
+                      ast::Intrinsic::kTextureSampleLevel},
+        IntrinsicData{"trunc", ast::Intrinsic::kTrunc}));
+
+TEST_F(TypeDeterminerTest, IntrinsicNotSetIfNotMatched) {
+  ast::IdentifierExpression ident("not_intrinsic");
+  td()->SetIntrinsicIfNeeded(&ident);
+  EXPECT_EQ(ident.intrinsic(), ast::Intrinsic::kNone);
+  EXPECT_FALSE(ident.IsIntrinsic());
+}
+
+using ImportData_SingleParamTest = TypeDeterminerTestWithParam<IntrinsicData>;
 TEST_P(ImportData_SingleParamTest, Scalar) {
   auto param = GetParam();
 
@@ -2489,14 +2574,13 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->is_float_scalar());
-  EXPECT_EQ(id, param.value);
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_float_scalar());
 }
 
 TEST_P(ImportData_SingleParamTest, Vector) {
@@ -2517,15 +2601,14 @@
   params.push_back(
       std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->is_float_vector());
-  EXPECT_EQ(type->AsVector()->size(), 3u);
-  EXPECT_EQ(id, param.value);
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_float_vector());
+  EXPECT_EQ(ident_ptr->result_type()->AsVector()->size(), 3u);
 }
 
 TEST_P(ImportData_SingleParamTest, Error_Integer) {
@@ -2537,12 +2620,10 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::SintLiteral>(&i32, 1)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             std::string("incorrect type for ") + param.name +
                 ". Requires float scalar or float vector values");
@@ -2552,10 +2633,11 @@
   auto param = GetParam();
 
   ast::ExpressionList params;
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
                                param.name + ". Expected 1 got 0");
 }
@@ -2572,12 +2654,10 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
                                param.name + ". Expected 1 got 3");
 }
@@ -2585,37 +2665,224 @@
 INSTANTIATE_TEST_SUITE_P(
     TypeDeterminerTest,
     ImportData_SingleParamTest,
-    testing::Values(GLSLData{"round", GLSLstd450Round},
-                    GLSLData{"roundeven", GLSLstd450RoundEven},
-                    GLSLData{"trunc", GLSLstd450Trunc},
-                    GLSLData{"fabs", GLSLstd450FAbs},
-                    GLSLData{"fsign", GLSLstd450FSign},
-                    GLSLData{"floor", GLSLstd450Floor},
-                    GLSLData{"ceil", GLSLstd450Ceil},
-                    GLSLData{"fract", GLSLstd450Fract},
-                    GLSLData{"radians", GLSLstd450Radians},
-                    GLSLData{"degrees", GLSLstd450Degrees},
-                    GLSLData{"sin", GLSLstd450Sin},
-                    GLSLData{"cos", GLSLstd450Cos},
-                    GLSLData{"tan", GLSLstd450Tan},
-                    GLSLData{"asin", GLSLstd450Asin},
-                    GLSLData{"acos", GLSLstd450Acos},
-                    GLSLData{"atan", GLSLstd450Atan},
-                    GLSLData{"sinh", GLSLstd450Sinh},
-                    GLSLData{"cosh", GLSLstd450Cosh},
-                    GLSLData{"tanh", GLSLstd450Tanh},
-                    GLSLData{"asinh", GLSLstd450Asinh},
-                    GLSLData{"acosh", GLSLstd450Acosh},
-                    GLSLData{"atanh", GLSLstd450Atanh},
-                    GLSLData{"exp", GLSLstd450Exp},
-                    GLSLData{"log", GLSLstd450Log},
-                    GLSLData{"exp2", GLSLstd450Exp2},
-                    GLSLData{"log2", GLSLstd450Log2},
-                    GLSLData{"sqrt", GLSLstd450Sqrt},
-                    GLSLData{"inversesqrt", GLSLstd450InverseSqrt},
-                    GLSLData{"normalize", GLSLstd450Normalize},
-                    GLSLData{"interpolateatcentroid",
-                             GLSLstd450InterpolateAtCentroid}));
+    testing::Values(IntrinsicData{"acos", ast::Intrinsic::kAcos},
+                    IntrinsicData{"asin", ast::Intrinsic::kAsin},
+                    IntrinsicData{"atan", ast::Intrinsic::kAtan},
+                    IntrinsicData{"ceil", ast::Intrinsic::kCeil},
+                    IntrinsicData{"cos", ast::Intrinsic::kCos},
+                    IntrinsicData{"cosh", ast::Intrinsic::kCosh},
+                    IntrinsicData{"exp", ast::Intrinsic::kExp},
+                    IntrinsicData{"exp2", ast::Intrinsic::kExp2},
+                    IntrinsicData{"floor", ast::Intrinsic::kFloor},
+                    IntrinsicData{"fract", ast::Intrinsic::kFract},
+                    IntrinsicData{"inverseSqrt", ast::Intrinsic::kInverseSqrt},
+                    IntrinsicData{"log", ast::Intrinsic::kLog},
+                    IntrinsicData{"log2", ast::Intrinsic::kLog2},
+                    IntrinsicData{"normalize", ast::Intrinsic::kNormalize},
+                    IntrinsicData{"round", ast::Intrinsic::kRound},
+                    IntrinsicData{"sign", ast::Intrinsic::kSign},
+                    IntrinsicData{"sin", ast::Intrinsic::kSin},
+                    IntrinsicData{"sinh", ast::Intrinsic::kSinh},
+                    IntrinsicData{"sqrt", ast::Intrinsic::kSqrt},
+                    IntrinsicData{"tan", ast::Intrinsic::kTan},
+                    IntrinsicData{"tanh", ast::Intrinsic::kTanh},
+                    IntrinsicData{"trunc", ast::Intrinsic::kTrunc}));
+
+using ImportData_SingleParam_FloatOrInt_Test =
+    TypeDeterminerTestWithParam<IntrinsicData>;
+TEST_P(ImportData_SingleParam_FloatOrInt_Test, Float_Scalar) {
+  auto param = GetParam();
+
+  ast::type::F32Type f32;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_float_scalar());
+}
+
+TEST_P(ImportData_SingleParam_FloatOrInt_Test, Float_Vector) {
+  auto param = GetParam();
+
+  ast::type::F32Type f32;
+  ast::type::VectorType vec(&f32, 3);
+
+  ast::ExpressionList vals;
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 3.0f)));
+
+  ast::ExpressionList params;
+  params.push_back(
+      std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_float_vector());
+  EXPECT_EQ(ident_ptr->result_type()->AsVector()->size(), 3u);
+}
+
+TEST_P(ImportData_SingleParam_FloatOrInt_Test, Sint_Scalar) {
+  auto param = GetParam();
+
+  ast::type::I32Type i32;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, -11)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->IsI32());
+}
+
+TEST_P(ImportData_SingleParam_FloatOrInt_Test, Sint_Vector) {
+  auto param = GetParam();
+
+  ast::type::I32Type i32;
+  ast::type::VectorType vec(&i32, 3);
+
+  ast::ExpressionList vals;
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 3)));
+
+  ast::ExpressionList params;
+  params.push_back(
+      std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_signed_integer_vector());
+  EXPECT_EQ(ident_ptr->result_type()->AsVector()->size(), 3u);
+}
+
+TEST_P(ImportData_SingleParam_FloatOrInt_Test, Uint_Scalar) {
+  auto param = GetParam();
+
+  ast::type::U32Type u32;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->IsU32());
+}
+
+TEST_P(ImportData_SingleParam_FloatOrInt_Test, Uint_Vector) {
+  auto param = GetParam();
+
+  ast::type::U32Type u32;
+  ast::type::VectorType vec(&u32, 3);
+
+  ast::ExpressionList vals;
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1.0f)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1.0f)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 3.0f)));
+
+  ast::ExpressionList params;
+  params.push_back(
+      std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_unsigned_integer_vector());
+  EXPECT_EQ(ident_ptr->result_type()->AsVector()->size(), 3u);
+}
+
+TEST_P(ImportData_SingleParam_FloatOrInt_Test, Error_Bool) {
+  auto param = GetParam();
+
+  ast::type::BoolType bool_type;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::BoolLiteral>(&bool_type, false)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
+  EXPECT_EQ(td()->error(),
+            std::string("incorrect type for ") + param.name +
+                ". Requires float or int, scalar or vector values");
+}
+
+TEST_P(ImportData_SingleParam_FloatOrInt_Test, Error_NoParams) {
+  auto param = GetParam();
+
+  ast::ExpressionList params;
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
+  EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
+                               param.name + ". Expected 1 got 0");
+}
+
+TEST_P(ImportData_SingleParam_FloatOrInt_Test, Error_MultipleParams) {
+  auto param = GetParam();
+
+  ast::type::F32Type f32;
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
+  EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
+                               param.name + ". Expected 1 got 3");
+}
+
+INSTANTIATE_TEST_SUITE_P(TypeDeterminerTest,
+                         ImportData_SingleParam_FloatOrInt_Test,
+                         testing::Values(IntrinsicData{"abs",
+                                                       ast::Intrinsic::kAbs}));
 
 TEST_F(TypeDeterminerTest, ImportData_Length_Scalar) {
   ast::type::F32Type f32;
@@ -2626,12 +2893,13 @@
 
   ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "length", params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->is_float_scalar());
-  EXPECT_EQ(id, GLSLstd450Length);
+  auto ident = std::make_unique<ast::IdentifierExpression>("length");
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_float_scalar());
 }
 
 TEST_F(TypeDeterminerTest, ImportData_Length_FloatVector) {
@@ -2650,14 +2918,13 @@
   params.push_back(
       std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>("length");
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "length", params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->is_float_scalar());
-  EXPECT_EQ(id, GLSLstd450Length);
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_float_scalar());
 }
 
 TEST_F(TypeDeterminerTest, ImportData_Length_Error_Integer) {
@@ -2667,12 +2934,10 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::SintLiteral>(&i32, 1)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>("length");
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "length", params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             "incorrect type for length. Requires float scalar or float vector "
             "values");
@@ -2680,10 +2945,11 @@
 
 TEST_F(TypeDeterminerTest, ImportData_Length_Error_NoParams) {
   ast::ExpressionList params;
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "length", params, &id);
-  ASSERT_EQ(type, nullptr);
+
+  auto ident = std::make_unique<ast::IdentifierExpression>("length");
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             "incorrect number of parameters for length. Expected 1 got 0");
 }
@@ -2698,18 +2964,15 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>("length");
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "length", params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             "incorrect number of parameters for length. Expected 1 got 3");
 }
 
-using ImportData_TwoParamTest = TypeDeterminerTestWithParam<GLSLData>;
-
+using ImportData_TwoParamTest = TypeDeterminerTestWithParam<IntrinsicData>;
 TEST_P(ImportData_TwoParamTest, Scalar) {
   auto param = GetParam();
 
@@ -2721,14 +2984,13 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->is_float_scalar());
-  EXPECT_EQ(id, param.value);
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_float_scalar());
 }
 
 TEST_P(ImportData_TwoParamTest, Vector) {
@@ -2759,15 +3021,14 @@
   params.push_back(std::make_unique<ast::TypeConstructorExpression>(
       &vec, std::move(vals_2)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->is_float_vector());
-  EXPECT_EQ(type->AsVector()->size(), 3u);
-  EXPECT_EQ(id, param.value);
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_float_vector());
+  EXPECT_EQ(ident_ptr->result_type()->AsVector()->size(), 3u);
 }
 
 TEST_P(ImportData_TwoParamTest, Error_Integer) {
@@ -2781,12 +3042,10 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::SintLiteral>(&i32, 2)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             std::string("incorrect type for ") + param.name +
                 ". Requires float scalar or float vector values");
@@ -2796,10 +3055,11 @@
   auto param = GetParam();
 
   ast::ExpressionList params;
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
                                param.name + ". Expected 2 got 0");
 }
@@ -2812,12 +3072,10 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
                                param.name + ". Expected 2 got 1");
 }
@@ -2849,12 +3107,10 @@
   params.push_back(std::make_unique<ast::TypeConstructorExpression>(
       &vec3, std::move(vals_2)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             std::string("mismatched parameter types for ") + param.name);
 }
@@ -2879,12 +3135,10 @@
   params.push_back(
       std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             std::string("mismatched parameter types for ") + param.name);
 }
@@ -2901,26 +3155,21 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
                                param.name + ". Expected 2 got 3");
 }
 
-INSTANTIATE_TEST_SUITE_P(TypeDeterminerTest,
-                         ImportData_TwoParamTest,
-                         testing::Values(GLSLData{"atan2", GLSLstd450Atan2},
-                                         GLSLData{"pow", GLSLstd450Pow},
-                                         GLSLData{"fmin", GLSLstd450FMin},
-                                         GLSLData{"fmax", GLSLstd450FMax},
-                                         GLSLData{"step", GLSLstd450Step},
-                                         GLSLData{"reflect", GLSLstd450Reflect},
-                                         GLSLData{"nmin", GLSLstd450NMin},
-                                         GLSLData{"nmax", GLSLstd450NMax}));
+INSTANTIATE_TEST_SUITE_P(
+    TypeDeterminerTest,
+    ImportData_TwoParamTest,
+    testing::Values(IntrinsicData{"atan2", ast::Intrinsic::kAtan2},
+                    IntrinsicData{"pow", ast::Intrinsic::kPow},
+                    IntrinsicData{"step", ast::Intrinsic::kStep},
+                    IntrinsicData{"reflect", ast::Intrinsic::kReflect}));
 
 TEST_F(TypeDeterminerTest, ImportData_Distance_Scalar) {
   ast::type::F32Type f32;
@@ -2931,14 +3180,13 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>("distance");
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "distance", params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->is_float_scalar());
-  EXPECT_EQ(id, GLSLstd450Distance);
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_float_scalar());
 }
 
 TEST_F(TypeDeterminerTest, ImportData_Distance_Vector) {
@@ -2967,14 +3215,13 @@
   params.push_back(std::make_unique<ast::TypeConstructorExpression>(
       &vec, std::move(vals_2)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>("distance");
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "distance", params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->IsF32());
-  EXPECT_EQ(id, GLSLstd450Distance);
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->IsF32());
 }
 
 TEST_F(TypeDeterminerTest, ImportData_Distance_Error_Integer) {
@@ -2986,12 +3233,10 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::SintLiteral>(&i32, 2)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>("distance");
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "distance", params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             "incorrect type for distance. Requires float scalar or float "
             "vector values");
@@ -2999,10 +3244,11 @@
 
 TEST_F(TypeDeterminerTest, ImportData_Distance_Error_NoParams) {
   ast::ExpressionList params;
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "distance", params, &id);
-  ASSERT_EQ(type, nullptr);
+
+  auto ident = std::make_unique<ast::IdentifierExpression>("distance");
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             "incorrect number of parameters for distance. Expected 2 got 0");
 }
@@ -3013,12 +3259,10 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>("distance");
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "distance", params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             "incorrect number of parameters for distance. Expected 2 got 1");
 }
@@ -3048,12 +3292,10 @@
   params.push_back(std::make_unique<ast::TypeConstructorExpression>(
       &vec3, std::move(vals_2)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>("distance");
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "distance", params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), "mismatched parameter types for distance");
 }
 
@@ -3075,12 +3317,10 @@
   params.push_back(
       std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>("distance");
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "distance", params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), "mismatched parameter types for distance");
 }
 
@@ -3094,12 +3334,10 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>("distance");
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "distance", params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             "incorrect number of parameters for distance. Expected 2 got 3");
 }
@@ -3130,15 +3368,14 @@
   params.push_back(std::make_unique<ast::TypeConstructorExpression>(
       &vec, std::move(vals_2)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>("cross");
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "cross", params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->is_float_vector());
-  EXPECT_EQ(type->AsVector()->size(), 3u);
-  EXPECT_EQ(id, GLSLstd450Cross);
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_float_vector());
+  EXPECT_EQ(ident_ptr->result_type()->AsVector()->size(), 3u);
 }
 
 TEST_F(TypeDeterminerTest, ImportData_Cross_Error_Scalar) {
@@ -3150,12 +3387,10 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>("cross");
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "cross", params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             "incorrect type for cross. Requires float vector values");
 }
@@ -3186,27 +3421,20 @@
   params.push_back(std::make_unique<ast::TypeConstructorExpression>(
       &vec, std::move(vals_2)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>("cross");
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "cross", params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             "incorrect type for cross. Requires float vector values");
 }
 
 TEST_F(TypeDeterminerTest, ImportData_Cross_Error_MissingParams) {
-  ast::type::F32Type f32;
-  ast::type::VectorType vec(&f32, 3);
-
   ast::ExpressionList params;
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>("cross");
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "cross", params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             "incorrect number of parameters for cross. Expected 2 got 0");
 }
@@ -3227,12 +3455,10 @@
   params.push_back(std::make_unique<ast::TypeConstructorExpression>(
       &vec, std::move(vals_1)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>("cross");
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "cross", params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             "incorrect number of parameters for cross. Expected 2 got 1");
 }
@@ -3273,17 +3499,15 @@
   params.push_back(std::make_unique<ast::TypeConstructorExpression>(
       &vec, std::move(vals_3)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>("cross");
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "cross", params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             "incorrect number of parameters for cross. Expected 2 got 3");
 }
 
-using ImportData_ThreeParamTest = TypeDeterminerTestWithParam<GLSLData>;
+using ImportData_ThreeParamTest = TypeDeterminerTestWithParam<IntrinsicData>;
 TEST_P(ImportData_ThreeParamTest, Scalar) {
   auto param = GetParam();
 
@@ -3297,14 +3521,13 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->is_float_scalar());
-  EXPECT_EQ(id, param.value);
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_float_scalar());
 }
 
 TEST_P(ImportData_ThreeParamTest, Vector) {
@@ -3345,15 +3568,14 @@
   params.push_back(std::make_unique<ast::TypeConstructorExpression>(
       &vec, std::move(vals_3)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->is_float_vector());
-  EXPECT_EQ(type->AsVector()->size(), 3u);
-  EXPECT_EQ(id, param.value);
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_float_vector());
+  EXPECT_EQ(ident_ptr->result_type()->AsVector()->size(), 3u);
 }
 
 TEST_P(ImportData_ThreeParamTest, Error_Integer) {
@@ -3369,12 +3591,10 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::SintLiteral>(&i32, 3)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             std::string("incorrect type for ") + param.name +
                 ". Requires float scalar or float vector values");
@@ -3384,10 +3604,11 @@
   auto param = GetParam();
 
   ast::ExpressionList params;
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
                                param.name + ". Expected 3 got 0");
 }
@@ -3400,12 +3621,10 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
                                param.name + ". Expected 3 got 1");
 }
@@ -3420,12 +3639,10 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
                                param.name + ". Expected 3 got 2");
 }
@@ -3467,12 +3684,10 @@
   params.push_back(std::make_unique<ast::TypeConstructorExpression>(
       &vec3, std::move(vals_3)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             std::string("mismatched parameter types for ") + param.name);
 }
@@ -3499,12 +3714,10 @@
   params.push_back(
       std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             std::string("mismatched parameter types for ") + param.name);
 }
@@ -3523,12 +3736,10 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
                                param.name + ". Expected 3 got 4");
 }
@@ -3536,14 +3747,397 @@
 INSTANTIATE_TEST_SUITE_P(
     TypeDeterminerTest,
     ImportData_ThreeParamTest,
-    testing::Values(GLSLData{"fclamp", GLSLstd450FClamp},
-                    GLSLData{"fmix", GLSLstd450FMix},
-                    GLSLData{"smoothstep", GLSLstd450SmoothStep},
-                    GLSLData{"fma", GLSLstd450Fma},
-                    GLSLData{"faceforward", GLSLstd450FaceForward},
-                    GLSLData{"nclamp", GLSLstd450NClamp}));
+    testing::Values(IntrinsicData{"mix", ast::Intrinsic::kMix},
+                    IntrinsicData{"smoothStep", ast::Intrinsic::kSmoothStep},
+                    IntrinsicData{"fma", ast::Intrinsic::kFma},
+                    IntrinsicData{"faceForward",
+                                  ast::Intrinsic::kFaceForward}));
 
-using ImportData_Int_SingleParamTest = TypeDeterminerTestWithParam<GLSLData>;
+using ImportData_ThreeParam_FloatOrInt_Test =
+    TypeDeterminerTestWithParam<IntrinsicData>;
+TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Float_Scalar) {
+  auto param = GetParam();
+
+  ast::type::F32Type f32;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_float_scalar());
+}
+
+TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Float_Vector) {
+  auto param = GetParam();
+
+  ast::type::F32Type f32;
+  ast::type::VectorType vec(&f32, 3);
+
+  ast::ExpressionList vals_1;
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 3.0f)));
+
+  ast::ExpressionList vals_2;
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 3.0f)));
+
+  ast::ExpressionList vals_3;
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 3.0f)));
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_1)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_2)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_3)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_float_vector());
+  EXPECT_EQ(ident_ptr->result_type()->AsVector()->size(), 3u);
+}
+
+TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Sint_Scalar) {
+  auto param = GetParam();
+
+  ast::type::I32Type i32;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->IsI32());
+}
+
+TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Sint_Vector) {
+  auto param = GetParam();
+
+  ast::type::I32Type i32;
+  ast::type::VectorType vec(&i32, 3);
+
+  ast::ExpressionList vals_1;
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 3)));
+
+  ast::ExpressionList vals_2;
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 3)));
+
+  ast::ExpressionList vals_3;
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 3)));
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_1)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_2)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_3)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_signed_integer_vector());
+  EXPECT_EQ(ident_ptr->result_type()->AsVector()->size(), 3u);
+}
+
+TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Uint_Scalar) {
+  auto param = GetParam();
+
+  ast::type::U32Type u32;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->IsU32());
+}
+
+TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Uint_Vector) {
+  auto param = GetParam();
+
+  ast::type::U32Type u32;
+  ast::type::VectorType vec(&u32, 3);
+
+  ast::ExpressionList vals_1;
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 3)));
+
+  ast::ExpressionList vals_2;
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 3)));
+
+  ast::ExpressionList vals_3;
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 3)));
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_1)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_2)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_3)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_unsigned_integer_vector());
+  EXPECT_EQ(ident_ptr->result_type()->AsVector()->size(), 3u);
+}
+
+TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Error_Bool) {
+  auto param = GetParam();
+
+  ast::type::BoolType bool_type;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::BoolLiteral>(&bool_type, true)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::BoolLiteral>(&bool_type, false)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::BoolLiteral>(&bool_type, true)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
+  EXPECT_EQ(td()->error(),
+            std::string("incorrect type for ") + param.name +
+                ". Requires float or int, scalar or vector values");
+}
+
+TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Error_NoParams) {
+  auto param = GetParam();
+
+  ast::ExpressionList params;
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
+  EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
+                               param.name + ". Expected 3 got 0");
+}
+
+TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Error_OneParam) {
+  auto param = GetParam();
+
+  ast::type::F32Type f32;
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
+  EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
+                               param.name + ". Expected 3 got 1");
+}
+
+TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Error_TwoParams) {
+  auto param = GetParam();
+
+  ast::type::F32Type f32;
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
+  EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
+                               param.name + ". Expected 3 got 2");
+}
+
+TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Error_MismatchedParamCount) {
+  auto param = GetParam();
+
+  ast::type::F32Type f32;
+  ast::type::VectorType vec2(&f32, 2);
+  ast::type::VectorType vec3(&f32, 3);
+
+  ast::ExpressionList vals_1;
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+
+  ast::ExpressionList vals_2;
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 3.0f)));
+
+  ast::ExpressionList vals_3;
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 3.0f)));
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec2, std::move(vals_1)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec3, std::move(vals_2)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec3, std::move(vals_3)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
+  EXPECT_EQ(td()->error(),
+            std::string("mismatched parameter types for ") + param.name);
+}
+
+TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Error_MismatchedParamType) {
+  auto param = GetParam();
+
+  ast::type::F32Type f32;
+  ast::type::VectorType vec(&f32, 3);
+
+  ast::ExpressionList vals;
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 3.0f)));
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.0f)));
+  params.push_back(
+      std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
+  EXPECT_EQ(td()->error(),
+            std::string("mismatched parameter types for ") + param.name);
+}
+
+TEST_P(ImportData_ThreeParam_FloatOrInt_Test, Error_TooManyParams) {
+  auto param = GetParam();
+
+  ast::type::F32Type f32;
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
+  EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
+                               param.name + ". Expected 3 got 4");
+}
+
+INSTANTIATE_TEST_SUITE_P(TypeDeterminerTest,
+                         ImportData_ThreeParam_FloatOrInt_Test,
+                         testing::Values(IntrinsicData{
+                             "clamp", ast::Intrinsic::kClamp}));
+
+using ImportData_Int_SingleParamTest =
+    TypeDeterminerTestWithParam<IntrinsicData>;
 TEST_P(ImportData_Int_SingleParamTest, Scalar) {
   auto param = GetParam();
 
@@ -3553,14 +4147,13 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::SintLiteral>(&i32, 1)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->is_integer_scalar());
-  EXPECT_EQ(id, param.value);
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_integer_scalar());
 }
 
 TEST_P(ImportData_Int_SingleParamTest, Vector) {
@@ -3581,15 +4174,14 @@
   params.push_back(
       std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->is_signed_integer_vector());
-  EXPECT_EQ(type->AsVector()->size(), 3u);
-  EXPECT_EQ(id, param.value);
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_signed_integer_vector());
+  EXPECT_EQ(ident_ptr->result_type()->AsVector()->size(), 3u);
 }
 
 TEST_P(ImportData_Int_SingleParamTest, Error_Float) {
@@ -3601,12 +4193,10 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             std::string("incorrect type for ") + param.name +
                 ". Requires integer scalar or integer vector values");
@@ -3616,10 +4206,11 @@
   auto param = GetParam();
 
   ast::ExpressionList params;
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
                                param.name + ". Expected 1 got 0");
 }
@@ -3636,12 +4227,10 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::SintLiteral>(&i32, 1)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
                                param.name + ". Expected 1 got 3");
 }
@@ -3649,14 +4238,13 @@
 INSTANTIATE_TEST_SUITE_P(
     TypeDeterminerTest,
     ImportData_Int_SingleParamTest,
-    testing::Values(GLSLData{"sabs", GLSLstd450SAbs},
-                    GLSLData{"ssign", GLSLstd450SSign},
-                    GLSLData{"findilsb", GLSLstd450FindILsb},
-                    GLSLData{"findumsb", GLSLstd450FindUMsb},
-                    GLSLData{"findsmsb", GLSLstd450FindSMsb}));
+    testing::Values(
+        IntrinsicData{"countOneBits", ast::Intrinsic::kCountOneBits},
+        IntrinsicData{"reverseBits", ast::Intrinsic::kReverseBits}));
 
-using ImportData_Int_TwoParamTest = TypeDeterminerTestWithParam<GLSLData>;
-TEST_P(ImportData_Int_TwoParamTest, Scalar_Signed) {
+using ImportData_FloatOrInt_TwoParamTest =
+    TypeDeterminerTestWithParam<IntrinsicData>;
+TEST_P(ImportData_FloatOrInt_TwoParamTest, Scalar_Signed) {
   auto param = GetParam();
 
   ast::type::I32Type i32;
@@ -3667,17 +4255,16 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::SintLiteral>(&i32, 1)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->IsI32());
-  EXPECT_EQ(id, param.value);
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->IsI32());
 }
 
-TEST_P(ImportData_Int_TwoParamTest, Scalar_Unsigned) {
+TEST_P(ImportData_FloatOrInt_TwoParamTest, Scalar_Unsigned) {
   auto param = GetParam();
 
   ast::type::U32Type u32;
@@ -3688,17 +4275,36 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::UintLiteral>(&u32, 1)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->IsU32());
-  EXPECT_EQ(id, param.value);
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->IsU32());
 }
 
-TEST_P(ImportData_Int_TwoParamTest, Vector_Signed) {
+TEST_P(ImportData_FloatOrInt_TwoParamTest, Scalar_Float) {
+  auto param = GetParam();
+
+  ast::type::F32Type f32;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->IsF32());
+}
+
+TEST_P(ImportData_FloatOrInt_TwoParamTest, Vector_Signed) {
   auto param = GetParam();
 
   ast::type::I32Type i32;
@@ -3726,18 +4332,17 @@
   params.push_back(std::make_unique<ast::TypeConstructorExpression>(
       &vec, std::move(vals_2)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->is_signed_integer_vector());
-  EXPECT_EQ(type->AsVector()->size(), 3u);
-  EXPECT_EQ(id, param.value);
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_signed_integer_vector());
+  EXPECT_EQ(ident_ptr->result_type()->AsVector()->size(), 3u);
 }
 
-TEST_P(ImportData_Int_TwoParamTest, Vector_Unsigned) {
+TEST_P(ImportData_FloatOrInt_TwoParamTest, Vector_Unsigned) {
   auto param = GetParam();
 
   ast::type::U32Type u32;
@@ -3765,52 +4370,88 @@
   params.push_back(std::make_unique<ast::TypeConstructorExpression>(
       &vec, std::move(vals_2)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->is_unsigned_integer_vector());
-  EXPECT_EQ(type->AsVector()->size(), 3u);
-  EXPECT_EQ(id, param.value);
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_unsigned_integer_vector());
+  EXPECT_EQ(ident_ptr->result_type()->AsVector()->size(), 3u);
 }
 
-TEST_P(ImportData_Int_TwoParamTest, Error_Float) {
+TEST_P(ImportData_FloatOrInt_TwoParamTest, Vector_Float) {
   auto param = GetParam();
 
   ast::type::F32Type f32;
+  ast::type::VectorType vec(&f32, 3);
+
+  ast::ExpressionList vals_1;
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 3)));
+
+  ast::ExpressionList vals_2;
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 3)));
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_1)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_2)));
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->is_float_vector());
+  EXPECT_EQ(ident_ptr->result_type()->AsVector()->size(), 3u);
+}
+
+TEST_P(ImportData_FloatOrInt_TwoParamTest, Error_Bool) {
+  auto param = GetParam();
+
+  ast::type::BoolType bool_type;
 
   ast::ExpressionList params;
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+      std::make_unique<ast::BoolLiteral>(&bool_type, true)));
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 2.f)));
+      std::make_unique<ast::BoolLiteral>(&bool_type, false)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             std::string("incorrect type for ") + param.name +
-                ". Requires integer scalar or integer vector values");
+                ". Requires float or int, scalar or vector values");
 }
 
-TEST_P(ImportData_Int_TwoParamTest, Error_NoParams) {
+TEST_P(ImportData_FloatOrInt_TwoParamTest, Error_NoParams) {
   auto param = GetParam();
 
   ast::ExpressionList params;
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
                                param.name + ". Expected 2 got 0");
 }
 
-TEST_P(ImportData_Int_TwoParamTest, Error_OneParam) {
+TEST_P(ImportData_FloatOrInt_TwoParamTest, Error_OneParam) {
   auto param = GetParam();
 
   ast::type::I32Type i32;
@@ -3818,17 +4459,15 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::SintLiteral>(&i32, 1)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
                                param.name + ". Expected 2 got 1");
 }
 
-TEST_P(ImportData_Int_TwoParamTest, Error_MismatchedParamCount) {
+TEST_P(ImportData_FloatOrInt_TwoParamTest, Error_MismatchedParamCount) {
   auto param = GetParam();
 
   ast::type::I32Type i32;
@@ -3855,17 +4494,15 @@
   params.push_back(std::make_unique<ast::TypeConstructorExpression>(
       &vec3, std::move(vals_2)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             std::string("mismatched parameter types for ") + param.name);
 }
 
-TEST_P(ImportData_Int_TwoParamTest, Error_MismatchedParamType) {
+TEST_P(ImportData_FloatOrInt_TwoParamTest, Error_MismatchedParamType) {
   auto param = GetParam();
 
   ast::type::I32Type i32;
@@ -3885,17 +4522,15 @@
   params.push_back(
       std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(),
             std::string("mismatched parameter types for ") + param.name);
 }
 
-TEST_P(ImportData_Int_TwoParamTest, Error_TooManyParams) {
+TEST_P(ImportData_FloatOrInt_TwoParamTest, Error_TooManyParams) {
   auto param = GetParam();
 
   ast::type::I32Type i32;
@@ -3907,22 +4542,19 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::SintLiteral>(&i32, 1)));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
                                param.name + ". Expected 2 got 3");
 }
 
-INSTANTIATE_TEST_SUITE_P(TypeDeterminerTest,
-                         ImportData_Int_TwoParamTest,
-                         testing::Values(GLSLData{"umin", GLSLstd450UMin},
-                                         GLSLData{"smin", GLSLstd450SMin},
-                                         GLSLData{"umax", GLSLstd450UMax},
-                                         GLSLData{"smax", GLSLstd450SMax}));
+INSTANTIATE_TEST_SUITE_P(
+    TypeDeterminerTest,
+    ImportData_FloatOrInt_TwoParamTest,
+    testing::Values(IntrinsicData{"min", ast::Intrinsic::kMin},
+                    IntrinsicData{"max", ast::Intrinsic::kMax}));
 
 TEST_F(TypeDeterminerTest, ImportData_GLSL_Determinant) {
   ast::type::F32Type f32;
@@ -3938,44 +4570,17 @@
   ast::ExpressionList params;
   params.push_back(std::make_unique<ast::IdentifierExpression>("var"));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>("determinant");
+  auto* ident_ptr = ident.get();
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "determinant", params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->IsF32());
-  EXPECT_EQ(id, GLSLstd450Determinant);
+  EXPECT_TRUE(td()->DetermineResultType(&call)) << td()->error();
+  ASSERT_NE(ident_ptr->result_type(), nullptr);
+  EXPECT_TRUE(ident_ptr->result_type()->IsF32());
 }
 
-TEST_F(TypeDeterminerTest, ImportData_GLSL_MatrixInverse) {
-  ast::type::F32Type f32;
-  ast::type::MatrixType mat(&f32, 3, 3);
-
-  auto var = std::make_unique<ast::Variable>(
-      "var", ast::StorageClass::kFunction, &mat);
-  mod()->AddGlobalVariable(std::move(var));
-
-  // Register the global
-  ASSERT_TRUE(td()->Determine()) << td()->error();
-
-  ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::IdentifierExpression>("var"));
-
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
-
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", "matrixinverse", params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->IsMatrix());
-  EXPECT_TRUE(type->AsMatrix()->type()->IsF32());
-  EXPECT_EQ(type->AsMatrix()->rows(), 3u);
-  EXPECT_EQ(type->AsMatrix()->columns(), 3u);
-  EXPECT_EQ(id, GLSLstd450MatrixInverse);
-}
-
-using ImportData_Matrix_OneParam_Test = TypeDeterminerTestWithParam<GLSLData>;
+using ImportData_Matrix_OneParam_Test =
+    TypeDeterminerTestWithParam<IntrinsicData>;
 TEST_P(ImportData_Matrix_OneParam_Test, Error_Float) {
   auto param = GetParam();
 
@@ -3991,12 +4596,10 @@
   ast::ExpressionList params;
   params.push_back(std::make_unique<ast::IdentifierExpression>("var"));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), std::string("incorrect type for ") + param.name +
                                ". Requires matrix value");
 }
@@ -4006,10 +4609,10 @@
 
   ast::ExpressionList params;
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
+
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
                                param.name + ". Expected 1 got 0");
 }
@@ -4031,347 +4634,17 @@
   params.push_back(std::make_unique<ast::IdentifierExpression>("var"));
   params.push_back(std::make_unique<ast::IdentifierExpression>("var"));
 
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression call(std::move(ident), std::move(params));
 
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
+  EXPECT_FALSE(td()->DetermineResultType(&call));
   EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
                                param.name + ". Expected 1 got 2");
 }
-INSTANTIATE_TEST_SUITE_P(
-    TypeDeterminerTest,
-    ImportData_Matrix_OneParam_Test,
-    testing::Values(GLSLData{"determinant", GLSLstd450Determinant},
-                    GLSLData{"matrixinverse", GLSLstd450MatrixInverse}));
-
-using ImportData_IntThreeParamTest = TypeDeterminerTestWithParam<GLSLData>;
-TEST_P(ImportData_IntThreeParamTest, Scalar_Signed) {
-  auto param = GetParam();
-
-  ast::type::I32Type i32;
-
-  ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
-
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->IsI32());
-  EXPECT_EQ(id, param.value);
-}
-
-TEST_P(ImportData_IntThreeParamTest, Scalar_Unsigned) {
-  auto param = GetParam();
-
-  ast::type::U32Type u32;
-
-  ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::UintLiteral>(&u32, 1u)));
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::UintLiteral>(&u32, 1u)));
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::UintLiteral>(&u32, 1u)));
-
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
-
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->IsU32());
-  EXPECT_EQ(id, param.value);
-}
-
-TEST_P(ImportData_IntThreeParamTest, Vector_Signed) {
-  auto param = GetParam();
-
-  ast::type::I32Type i32;
-  ast::type::VectorType vec(&i32, 3);
-
-  ast::ExpressionList vals_1;
-  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 3)));
-
-  ast::ExpressionList vals_2;
-  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 3)));
-
-  ast::ExpressionList vals_3;
-  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 3)));
-
-  ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
-      &vec, std::move(vals_1)));
-  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
-      &vec, std::move(vals_2)));
-  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
-      &vec, std::move(vals_3)));
-
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
-
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->is_signed_integer_vector());
-  EXPECT_EQ(type->AsVector()->size(), 3u);
-  EXPECT_EQ(id, param.value);
-}
-
-TEST_P(ImportData_IntThreeParamTest, Vector_Unsigned) {
-  auto param = GetParam();
-
-  ast::type::U32Type u32;
-  ast::type::VectorType vec(&u32, 3);
-
-  ast::ExpressionList vals_1;
-  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::UintLiteral>(&u32, 1u)));
-  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::UintLiteral>(&u32, 1u)));
-  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::UintLiteral>(&u32, 3u)));
-
-  ast::ExpressionList vals_2;
-  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::UintLiteral>(&u32, 1u)));
-  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::UintLiteral>(&u32, 1u)));
-  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::UintLiteral>(&u32, 3u)));
-
-  ast::ExpressionList vals_3;
-  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::UintLiteral>(&u32, 1u)));
-  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::UintLiteral>(&u32, 1u)));
-  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::UintLiteral>(&u32, 3u)));
-
-  ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
-      &vec, std::move(vals_1)));
-  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
-      &vec, std::move(vals_2)));
-  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
-      &vec, std::move(vals_3)));
-
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
-
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_NE(type, nullptr);
-  EXPECT_TRUE(type->is_unsigned_integer_vector());
-  EXPECT_EQ(type->AsVector()->size(), 3u);
-  EXPECT_EQ(id, param.value);
-}
-
-TEST_P(ImportData_IntThreeParamTest, Error_Float) {
-  auto param = GetParam();
-
-  ast::type::F32Type f32;
-
-  ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 2.f)));
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 3.f)));
-
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
-
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
-  EXPECT_EQ(td()->error(),
-            std::string("incorrect type for ") + param.name +
-                ". Requires integer scalar or integer vector values");
-}
-
-TEST_P(ImportData_IntThreeParamTest, Error_NoParams) {
-  auto param = GetParam();
-
-  ast::ExpressionList params;
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
-  EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
-                               param.name + ". Expected 3 got 0");
-}
-
-TEST_P(ImportData_IntThreeParamTest, Error_OneParam) {
-  auto param = GetParam();
-
-  ast::type::I32Type i32;
-  ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
-
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
-  EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
-                               param.name + ". Expected 3 got 1");
-}
-
-TEST_P(ImportData_IntThreeParamTest, Error_TwoParams) {
-  auto param = GetParam();
-
-  ast::type::I32Type i32;
-  ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
-
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
-  EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
-                               param.name + ". Expected 3 got 2");
-}
-
-TEST_P(ImportData_IntThreeParamTest, Error_MismatchedParamCount) {
-  auto param = GetParam();
-
-  ast::type::I32Type i32;
-  ast::type::VectorType vec2(&i32, 2);
-  ast::type::VectorType vec3(&i32, 3);
-
-  ast::ExpressionList vals_1;
-  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-
-  ast::ExpressionList vals_2;
-  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 3)));
-
-  ast::ExpressionList vals_3;
-  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 3)));
-
-  ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
-      &vec2, std::move(vals_1)));
-  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
-      &vec3, std::move(vals_2)));
-  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
-      &vec3, std::move(vals_3)));
-
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
-
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
-  EXPECT_EQ(td()->error(),
-            std::string("mismatched parameter types for ") + param.name);
-}
-
-TEST_P(ImportData_IntThreeParamTest, Error_MismatchedParamType) {
-  auto param = GetParam();
-
-  ast::type::I32Type i32;
-  ast::type::VectorType vec(&i32, 3);
-
-  ast::ExpressionList vals;
-  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 3)));
-
-  ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  params.push_back(
-      std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals)));
-
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
-
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
-  EXPECT_EQ(td()->error(),
-            std::string("mismatched parameter types for ") + param.name);
-}
-
-TEST_P(ImportData_IntThreeParamTest, Error_TooManyParams) {
-  auto param = GetParam();
-
-  ast::type::I32Type i32;
-  ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::SintLiteral>(&i32, 1)));
-
-  ASSERT_TRUE(td()->DetermineResultType(params)) << td()->error();
-
-  uint32_t id = 0;
-  auto* type =
-      td()->GetImportData({0, 0}, "GLSL.std.450", param.name, params, &id);
-  ASSERT_EQ(type, nullptr);
-  EXPECT_EQ(td()->error(), std::string("incorrect number of parameters for ") +
-                               param.name + ". Expected 3 got 4");
-}
-
 INSTANTIATE_TEST_SUITE_P(TypeDeterminerTest,
-                         ImportData_IntThreeParamTest,
-                         testing::Values(GLSLData{"sclamp", GLSLstd450SClamp},
-                                         GLSLData{"uclamp", GLSLstd450UClamp}));
+                         ImportData_Matrix_OneParam_Test,
+                         testing::Values(IntrinsicData{
+                             "determinant", ast::Intrinsic::kDeterminant}));
 
 TEST_F(TypeDeterminerTest, Function_EntryPoints_StageDecoration) {
   ast::type::F32Type f32;
diff --git a/src/validator_impl.cc b/src/validator_impl.cc
index 2a8ce16..a7e58d1 100644
--- a/src/validator_impl.cc
+++ b/src/validator_impl.cc
@@ -46,9 +46,6 @@
   if (!ValidateGlobalVariables(module->global_variables())) {
     return false;
   }
-  if (!CheckImports(module)) {
-    return false;
-  }
   if (!ValidateFunctions(module->functions())) {
     return false;
   }
@@ -330,9 +327,7 @@
   if (expr->func()->IsIdentifier()) {
     auto* ident = expr->func()->AsIdentifier();
     auto func_name = ident->name();
-    if (ident->has_path()) {
-      // TODO(sarahM0): validate import statements
-    } else if (ast::intrinsic::IsIntrinsic(ident->name())) {
+    if (ident->IsIntrinsic()) {
       // TODO(sarahM0): validate intrinsics - tied with type-determiner
     } else {
       if (!function_stack_.has(func_name)) {
@@ -433,14 +428,4 @@
   return true;
 }
 
-bool ValidatorImpl::CheckImports(const ast::Module* module) {
-  for (const auto& import : module->imports()) {
-    if (import->path() != "GLSL.std.450") {
-      set_error(import->source(), "v-0001: unknown import: " + import->path());
-      return false;
-    }
-  }
-  return true;
-}
-
 }  // namespace tint
diff --git a/src/validator_impl.h b/src/validator_impl.h
index 6481292..4a5fe64 100644
--- a/src/validator_impl.h
+++ b/src/validator_impl.h
@@ -76,10 +76,6 @@
   /// @param assign the assignment to check
   /// @returns true if the validation was successful
   bool ValidateAssign(const ast::AssignmentStatement* assign);
-  /// Validates v-0001: Only allowed import is "GLSL.std.450"
-  /// @param module the modele to check imports
-  /// @returns ture if input complies with v-0001 rule
-  bool CheckImports(const ast::Module* module);
   /// Validates an expression
   /// @param expr the expression to check
   /// @return true if the expression is valid
diff --git a/src/validator_test.cc b/src/validator_test.cc
index 8658f25..8381e5c 100644
--- a/src/validator_test.cc
+++ b/src/validator_test.cc
@@ -63,33 +63,6 @@
 
 class ValidatorTest : public ValidatorTestHelper, public testing::Test {};
 
-TEST_F(ValidatorTest, Import) {
-  ast::Module m;
-  m.AddImport(std::make_unique<ast::Import>("GLSL.std.450", "glsl"));
-
-  EXPECT_TRUE(v()->CheckImports(&m));
-}
-
-TEST_F(ValidatorTest, Import_Fail_NotGLSL) {
-  ast::Module m;
-  m.AddImport(
-      std::make_unique<ast::Import>(Source{12, 34}, "not.GLSL", "glsl"));
-
-  EXPECT_FALSE(v()->CheckImports(&m));
-  ASSERT_TRUE(v()->has_error());
-  EXPECT_EQ(v()->error(), "12:34: v-0001: unknown import: not.GLSL");
-}
-
-TEST_F(ValidatorTest, Import_Fail_Typo) {
-  ast::Module m;
-  m.AddImport(
-      std::make_unique<ast::Import>(Source{12, 34}, "GLSL.std.4501", "glsl"));
-
-  EXPECT_FALSE(v()->CheckImports(&m));
-  ASSERT_TRUE(v()->has_error());
-  EXPECT_EQ(v()->error(), "12:34: v-0001: unknown import: GLSL.std.4501");
-}
-
 TEST_F(ValidatorTest, DISABLED_AssignToScalar_Fail) {
   // 1 = my_var;
   ast::type::I32Type i32;
diff --git a/src/writer/hlsl/generator_impl.cc b/src/writer/hlsl/generator_impl.cc
index 7fa9229..bd20995 100644
--- a/src/writer/hlsl/generator_impl.cc
+++ b/src/writer/hlsl/generator_impl.cc
@@ -16,7 +16,6 @@
 
 #include <sstream>
 
-#include "spirv/unified1/GLSL.std.450.h"
 #include "src/ast/array_accessor_expression.h"
 #include "src/ast/as_expression.h"
 #include "src/ast/assignment_statement.h"
@@ -31,7 +30,6 @@
 #include "src/ast/float_literal.h"
 #include "src/ast/identifier_expression.h"
 #include "src/ast/if_statement.h"
-#include "src/ast/intrinsic.h"
 #include "src/ast/loop_statement.h"
 #include "src/ast/member_accessor_expression.h"
 #include "src/ast/return_statement.h"
@@ -469,44 +467,46 @@
   return true;
 }
 
-std::string GeneratorImpl::generate_intrinsic_name(const std::string& name) {
-  if (name == "any") {
+std::string GeneratorImpl::generate_intrinsic_name(ast::Intrinsic intrinsic) {
+  if (intrinsic == ast::Intrinsic::kAny) {
     return "any";
   }
-  if (name == "all") {
+  if (intrinsic == ast::Intrinsic::kAll) {
     return "all";
   }
-  if (name == "dot") {
+  if (intrinsic == ast::Intrinsic::kDot) {
     return "dot";
   }
-  if (name == "is_finite") {
+  if (intrinsic == ast::Intrinsic::kIsFinite) {
     return "isfinite";
   }
-  if (name == "is_inf") {
+  if (intrinsic == ast::Intrinsic::kIsInf) {
     return "isinf";
   }
-  if (name == "is_nan") {
+  if (intrinsic == ast::Intrinsic::kIsNan) {
     return "isnan";
   }
-  if (name == "dpdy") {
+  if (intrinsic == ast::Intrinsic::kDpdy) {
     return "ddy";
   }
-  if (name == "dpdy_fine") {
+  if (intrinsic == ast::Intrinsic::kDpdyFine) {
     return "ddy_fine";
   }
-  if (name == "dpdy_coarse") {
+  if (intrinsic == ast::Intrinsic::kDpdyCoarse) {
     return "ddy_coarse";
   }
-  if (name == "dpdx") {
+  if (intrinsic == ast::Intrinsic::kDpdx) {
     return "ddx";
   }
-  if (name == "dpdx_fine") {
+  if (intrinsic == ast::Intrinsic::kDpdxFine) {
     return "ddx_fine";
   }
-  if (name == "dpdx_coarse") {
+  if (intrinsic == ast::Intrinsic::kDpdxCoarse) {
     return "ddx_coarse";
   }
-  if (name == "fwidth" || name == "fwidth_fine" || name == "fwidth_coarse") {
+  if (intrinsic == ast::Intrinsic::kFwidth ||
+      intrinsic == ast::Intrinsic::kFwidthFine ||
+      intrinsic == ast::Intrinsic::kFwidthCoarse) {
     return "fwidth";
   }
   return "";
@@ -521,15 +521,15 @@
   }
 
   auto* ident = expr->func()->AsIdentifier();
-  if (!ident->has_path() && ast::intrinsic::IsIntrinsic(ident->name())) {
+  if (ident->IsIntrinsic()) {
     const auto& params = expr->params();
-    if (ident->name() == "select") {
+    if (ident->intrinsic() == ast::Intrinsic::kSelect) {
       error_ = "select not supported in HLSL backend yet";
       return false;
-    } else if (ident->name() == "is_normal") {
+    } else if (ident->intrinsic() == ast::Intrinsic::kIsNormal) {
       error_ = "is_normal not supported in HLSL backend yet";
       return false;
-    } else if (ident->name() == "outer_product") {
+    } else if (ident->intrinsic() == ast::Intrinsic::kOuterProduct) {
       error_ = "outer_product not supported yet";
       return false;
       // TODO(dsinclair): This gets tricky. We need to generate two variables to
@@ -582,11 +582,15 @@
 
       // out << ")";
     } else {
-      auto name = generate_intrinsic_name(ident->name());
+      auto name = generate_intrinsic_name(ident->intrinsic());
       if (name.empty()) {
-        error_ = "unable to determine intrinsic name for intrinsic: " +
-                 ident->name();
-        return false;
+        if (ast::intrinsic::IsTextureIntrinsic(ident->intrinsic())) {
+          error_ = "Textures not implemented yet";
+          return false;
+        }
+        if (!EmitBuiltinName(pre, out, expr)) {
+          return false;
+        }
       }
 
       make_indent(out);
@@ -609,162 +613,39 @@
     return true;
   }
 
-  if (!ident->has_path()) {
-    auto name = ident->name();
-    auto it = ep_func_name_remapped_.find(current_ep_name_ + "_" + name);
-    if (it != ep_func_name_remapped_.end()) {
-      name = it->second;
-    }
+  auto name = ident->name();
+  auto it = ep_func_name_remapped_.find(current_ep_name_ + "_" + name);
+  if (it != ep_func_name_remapped_.end()) {
+    name = it->second;
+  }
 
-    auto* func = module_->FindFunctionByName(ident->name());
-    if (func == nullptr) {
-      error_ = "Unable to find function: " + name;
-      return false;
-    }
+  auto* func = module_->FindFunctionByName(ident->name());
+  if (func == nullptr) {
+    error_ = "Unable to find function: " + name;
+    return false;
+  }
 
-    out << name << "(";
+  out << name << "(";
 
-    bool first = true;
-    if (has_referenced_in_var_needing_struct(func)) {
-      auto var_name = current_ep_var_name(VarType::kIn);
-      if (!var_name.empty()) {
-        out << var_name;
-        first = false;
-      }
+  bool first = true;
+  if (has_referenced_in_var_needing_struct(func)) {
+    auto var_name = current_ep_var_name(VarType::kIn);
+    if (!var_name.empty()) {
+      out << var_name;
+      first = false;
     }
-    if (has_referenced_out_var_needing_struct(func)) {
-      auto var_name = current_ep_var_name(VarType::kOut);
-      if (!var_name.empty()) {
-        if (!first) {
-          out << ", ";
-        }
-        first = false;
-        out << var_name;
-      }
-    }
-
-    const auto& params = expr->params();
-    for (const auto& param : params) {
+  }
+  if (has_referenced_out_var_needing_struct(func)) {
+    auto var_name = current_ep_var_name(VarType::kOut);
+    if (!var_name.empty()) {
       if (!first) {
         out << ", ";
       }
       first = false;
-
-      if (!EmitExpression(pre, out, param.get())) {
-        return false;
-      }
+      out << var_name;
     }
-
-    out << ")";
-  } else {
-    return EmitImportFunction(pre, out, expr);
-  }
-  return true;
-}
-
-bool GeneratorImpl::EmitImportFunction(std::ostream& pre,
-                                       std::ostream& out,
-                                       ast::CallExpression* expr) {
-  auto* ident = expr->func()->AsIdentifier();
-
-  auto* imp = module_->FindImportByName(ident->path());
-  if (imp == nullptr) {
-    error_ = "unable to find import for " + ident->path();
-    return 0;
-  }
-  auto id = imp->GetIdForMethod(ident->name());
-  if (id == 0) {
-    error_ = "unable to lookup: " + ident->name() + " in " + ident->path();
   }
 
-  switch (id) {
-    case GLSLstd450Acos:
-    case GLSLstd450Asin:
-    case GLSLstd450Atan:
-    case GLSLstd450Atan2:
-    case GLSLstd450Ceil:
-    case GLSLstd450Cos:
-    case GLSLstd450Cosh:
-    case GLSLstd450Cross:
-    case GLSLstd450Degrees:
-    case GLSLstd450Determinant:
-    case GLSLstd450Distance:
-    case GLSLstd450Exp:
-    case GLSLstd450Exp2:
-    case GLSLstd450FaceForward:
-    case GLSLstd450Floor:
-    case GLSLstd450Fma:
-    case GLSLstd450Length:
-    case GLSLstd450Log:
-    case GLSLstd450Log2:
-    case GLSLstd450Normalize:
-    case GLSLstd450Pow:
-    case GLSLstd450Radians:
-    case GLSLstd450Reflect:
-    case GLSLstd450Round:
-    case GLSLstd450Sin:
-    case GLSLstd450Sinh:
-    case GLSLstd450SmoothStep:
-    case GLSLstd450Sqrt:
-    case GLSLstd450Step:
-    case GLSLstd450Tan:
-    case GLSLstd450Tanh:
-    case GLSLstd450Trunc:
-      out << ident->name();
-      break;
-    case GLSLstd450Fract:
-      out << "frac";
-      break;
-    case GLSLstd450InterpolateAtCentroid:
-      out << "EvaluateAttributeAtCentroid";
-      break;
-    case GLSLstd450InverseSqrt:
-      out << "rsqrt";
-      break;
-    case GLSLstd450FMix:
-      out << "mix";
-      break;
-    case GLSLstd450SSign:
-    case GLSLstd450FSign:
-      out << "sign";
-      break;
-    case GLSLstd450FAbs:
-    case GLSLstd450SAbs:
-      out << "abs";
-      break;
-    case GLSLstd450FMax:
-    case GLSLstd450NMax:
-    case GLSLstd450SMax:
-    case GLSLstd450UMax:
-      out << "max";
-      break;
-    case GLSLstd450FMin:
-    case GLSLstd450NMin:
-    case GLSLstd450SMin:
-    case GLSLstd450UMin:
-      out << "min";
-      break;
-    case GLSLstd450FClamp:
-    case GLSLstd450SClamp:
-    case GLSLstd450NClamp:
-    case GLSLstd450UClamp:
-      out << "clamp";
-      break;
-    // TODO(dsinclair): Determine mappings for the following
-    case GLSLstd450Atanh:
-    case GLSLstd450Asinh:
-    case GLSLstd450Acosh:
-    case GLSLstd450FindILsb:
-    case GLSLstd450FindUMsb:
-    case GLSLstd450FindSMsb:
-    case GLSLstd450MatrixInverse:
-    case GLSLstd450RoundEven:
-      error_ = "Unknown import method: " + ident->name();
-      return false;
-  }
-
-  out << "(";
-  bool first = true;
   const auto& params = expr->params();
   for (const auto& param : params) {
     if (!first) {
@@ -776,11 +657,73 @@
       return false;
     }
   }
+
   out << ")";
 
   return true;
 }
 
+bool GeneratorImpl::EmitBuiltinName(std::ostream&,
+                                    std::ostream& out,
+                                    ast::CallExpression* expr) {
+  auto* ident = expr->func()->AsIdentifier();
+  switch (ident->intrinsic()) {
+    case ast::Intrinsic::kAcos:
+    case ast::Intrinsic::kAsin:
+    case ast::Intrinsic::kAtan:
+    case ast::Intrinsic::kAtan2:
+    case ast::Intrinsic::kCeil:
+    case ast::Intrinsic::kCos:
+    case ast::Intrinsic::kCosh:
+    case ast::Intrinsic::kCross:
+    case ast::Intrinsic::kDeterminant:
+    case ast::Intrinsic::kDistance:
+    case ast::Intrinsic::kExp:
+    case ast::Intrinsic::kExp2:
+    case ast::Intrinsic::kFloor:
+    case ast::Intrinsic::kFma:
+    case ast::Intrinsic::kLength:
+    case ast::Intrinsic::kLog:
+    case ast::Intrinsic::kLog2:
+    case ast::Intrinsic::kNormalize:
+    case ast::Intrinsic::kPow:
+    case ast::Intrinsic::kReflect:
+    case ast::Intrinsic::kRound:
+    case ast::Intrinsic::kSin:
+    case ast::Intrinsic::kSinh:
+    case ast::Intrinsic::kSqrt:
+    case ast::Intrinsic::kStep:
+    case ast::Intrinsic::kTan:
+    case ast::Intrinsic::kTanh:
+    case ast::Intrinsic::kTrunc:
+    case ast::Intrinsic::kMix:
+    case ast::Intrinsic::kSign:
+    case ast::Intrinsic::kAbs:
+    case ast::Intrinsic::kMax:
+    case ast::Intrinsic::kMin:
+    case ast::Intrinsic::kClamp:
+      out << ident->name();
+      break;
+    case ast::Intrinsic::kFaceForward:
+      out << "faceforward";
+      break;
+    case ast::Intrinsic::kFract:
+      out << "frac";
+      break;
+    case ast::Intrinsic::kInverseSqrt:
+      out << "rsqrt";
+      break;
+    case ast::Intrinsic::kSmoothStep:
+      out << "smoothstep";
+      break;
+    default:
+      error_ = "Unknown builtin method: " + ident->name();
+      return false;
+  }
+
+  return true;
+}
+
 bool GeneratorImpl::EmitCast(std::ostream& pre,
                              std::ostream& out,
                              ast::CastExpression* expr) {
@@ -957,12 +900,6 @@
                                    std::ostream& out,
                                    ast::IdentifierExpression* expr) {
   auto* ident = expr->AsIdentifier();
-  if (ident->has_path()) {
-    // TODO(dsinclair): Handle identifier with path
-    error_ = "Identifier paths not handled yet.";
-    return false;
-  }
-
   ast::Variable* var = nullptr;
   if (global_variables_.get(ident->name(), &var)) {
     if (global_is_in_struct(var)) {
@@ -1832,10 +1769,6 @@
   // Check if this is a storage buffer variable
   if (structure->IsIdentifier()) {
     auto* ident = expr->structure()->AsIdentifier();
-    if (ident->has_path()) {
-      return false;
-    }
-
     ast::Variable* var = nullptr;
     if (!global_variables_.get(ident->name(), &var)) {
       return false;
diff --git a/src/writer/hlsl/generator_impl.h b/src/writer/hlsl/generator_impl.h
index 798bf87..031cf7e 100644
--- a/src/writer/hlsl/generator_impl.h
+++ b/src/writer/hlsl/generator_impl.h
@@ -15,6 +15,7 @@
 #ifndef SRC_WRITER_HLSL_GENERATOR_IMPL_H_
 #define SRC_WRITER_HLSL_GENERATOR_IMPL_H_
 
+#include "src/ast/intrinsic.h"
 #include "src/ast/literal.h"
 #include "src/ast/module.h"
 #include "src/ast/scalar_constructor_expression.h"
@@ -206,14 +207,14 @@
   /// @param stmt the statement to emit
   /// @returns true if the statement was successfully emitted
   bool EmitIf(std::ostream& out, ast::IfStatement* stmt);
-  /// Handles genreating an import expression
+  /// Handles generating a builtin method name
   /// @param pre the preamble for the expression stream
   /// @param out the output of the expression stream
   /// @param expr the expression
-  /// @returns true if the expression was successfully emitted.
-  bool EmitImportFunction(std::ostream& pre,
-                          std::ostream& out,
-                          ast::CallExpression* expr);
+  /// @returns true if the name was successfully emitted.
+  bool EmitBuiltinName(std::ostream& pre,
+                       std::ostream& out,
+                       ast::CallExpression* expr);
   /// Handles a literal
   /// @param out the output stream
   /// @param lit the literal to emit
@@ -327,9 +328,9 @@
   /// @returns the name
   std::string generate_name(const std::string& prefix);
   /// Generates an intrinsic name from the given name
-  /// @param name the name to convert to an intrinsic
+  /// @param intrinsic the intrinsic to convert to a name
   /// @returns the intrinsic name or blank on error
-  std::string generate_intrinsic_name(const std::string& name);
+  std::string generate_intrinsic_name(ast::Intrinsic intrinsic);
   /// Converts a builtin to an attribute name
   /// @param builtin the builtin to convert
   /// @returns the string name of the builtin or blank on error
diff --git a/src/writer/hlsl/generator_impl_identifier_test.cc b/src/writer/hlsl/generator_impl_identifier_test.cc
index 56f15bb..bf38e8d 100644
--- a/src/writer/hlsl/generator_impl_identifier_test.cc
+++ b/src/writer/hlsl/generator_impl_identifier_test.cc
@@ -23,13 +23,7 @@
 
 using HlslGeneratorImplTest_Identifier = TestHelper;
 
-TEST_F(HlslGeneratorImplTest_Identifier, DISABLED_EmitExpression_Identifier) {
-  ast::IdentifierExpression i(std::vector<std::string>{"std", "glsl"});
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &i)) << gen().error();
-  EXPECT_EQ(result(), "std::glsl");
-}
-
-TEST_F(HlslGeneratorImplTest_Identifier, EmitIdentifierExpression_Single) {
+TEST_F(HlslGeneratorImplTest_Identifier, EmitIdentifierExpression) {
   ast::IdentifierExpression i("foo");
   ASSERT_TRUE(gen().EmitExpression(pre(), out(), &i)) << gen().error();
   EXPECT_EQ(result(), "foo");
@@ -42,14 +36,6 @@
   EXPECT_EQ(result(), "virtual_tint_0");
 }
 
-// TODO(dsinclair): Handle import names
-TEST_F(HlslGeneratorImplTest_Identifier,
-       DISABLED_EmitIdentifierExpression_MultipleNames) {
-  ast::IdentifierExpression i({"std", "glsl", "init"});
-  ASSERT_TRUE(gen().EmitExpression(pre(), out(), &i)) << gen().error();
-  EXPECT_EQ(result(), "std::glsl::init");
-}
-
 }  // namespace
 }  // namespace hlsl
 }  // namespace writer
diff --git a/src/writer/hlsl/generator_impl_import_test.cc b/src/writer/hlsl/generator_impl_import_test.cc
index 8bea055..4cd8a61 100644
--- a/src/writer/hlsl/generator_impl_import_test.cc
+++ b/src/writer/hlsl/generator_impl_import_test.cc
@@ -58,59 +58,40 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
 
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", param.name}),
-                           std::move(params));
-
-  mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  ast::CallExpression expr(std::move(ident), std::move(params));
 
   ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
-  ASSERT_TRUE(gen().EmitImportFunction(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen().EmitCall(pre(), out(), &expr)) << gen().error();
   EXPECT_EQ(result(), std::string(param.hlsl_name) + "(1.00000000f)");
 }
-INSTANTIATE_TEST_SUITE_P(
-    HlslGeneratorImplTest_Import,
-    HlslImportData_SingleParamTest,
-    testing::Values(HlslImportData{"acos", "acos"},
-                    HlslImportData{"asin", "asin"},
-                    HlslImportData{"atan", "atan"},
-                    HlslImportData{"cos", "cos"},
-                    HlslImportData{"cosh", "cosh"},
-                    HlslImportData{"ceil", "ceil"},
-                    HlslImportData{"degrees", "degrees"},
-                    HlslImportData{"exp", "exp"},
-                    HlslImportData{"exp2", "exp2"},
-                    HlslImportData{"fabs", "abs"},
-                    HlslImportData{"floor", "floor"},
-                    HlslImportData{"fract", "frac"},
-                    HlslImportData{"interpolateatcentroid",
-                                   "EvaluateAttributeAtCentroid"},
-                    HlslImportData{"inversesqrt", "rsqrt"},
-                    HlslImportData{"length", "length"},
-                    HlslImportData{"log", "log"},
-                    HlslImportData{"log2", "log2"},
-                    HlslImportData{"normalize", "normalize"},
-                    HlslImportData{"radians", "radians"},
-                    HlslImportData{"round", "round"},
-                    HlslImportData{"fsign", "sign"},
-                    HlslImportData{"sin", "sin"},
-                    HlslImportData{"sinh", "sinh"},
-                    HlslImportData{"sqrt", "sqrt"},
-                    HlslImportData{"tan", "tan"},
-                    HlslImportData{"tanh", "tanh"},
-                    HlslImportData{"trunc", "trunc"}));
-
-TEST_F(HlslGeneratorImplTest_Import, DISABLED_HlslImportData_Acosh) {
-  FAIL();
-}
-
-TEST_F(HlslGeneratorImplTest_Import, DISABLED_HlslImportData_ASinh) {
-  FAIL();
-}
-
-TEST_F(HlslGeneratorImplTest_Import, DISABLED_HlslImportData_ATanh) {
-  FAIL();
-}
+INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
+                         HlslImportData_SingleParamTest,
+                         testing::Values(HlslImportData{"abs", "abs"},
+                                         HlslImportData{"acos", "acos"},
+                                         HlslImportData{"asin", "asin"},
+                                         HlslImportData{"atan", "atan"},
+                                         HlslImportData{"cos", "cos"},
+                                         HlslImportData{"cosh", "cosh"},
+                                         HlslImportData{"ceil", "ceil"},
+                                         HlslImportData{"exp", "exp"},
+                                         HlslImportData{"exp2", "exp2"},
+                                         HlslImportData{"floor", "floor"},
+                                         HlslImportData{"fract", "frac"},
+                                         HlslImportData{"inverseSqrt", "rsqrt"},
+                                         HlslImportData{"length", "length"},
+                                         HlslImportData{"log", "log"},
+                                         HlslImportData{"log2", "log2"},
+                                         HlslImportData{"normalize",
+                                                        "normalize"},
+                                         HlslImportData{"round", "round"},
+                                         HlslImportData{"sign", "sign"},
+                                         HlslImportData{"sin", "sin"},
+                                         HlslImportData{"sinh", "sinh"},
+                                         HlslImportData{"sqrt", "sqrt"},
+                                         HlslImportData{"tan", "tan"},
+                                         HlslImportData{"tanh", "tanh"},
+                                         HlslImportData{"trunc", "trunc"}));
 
 using HlslImportData_SingleIntParamTest =
     TestHelperBase<testing::TestWithParam<HlslImportData>>;
@@ -123,20 +104,17 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::SintLiteral>(&i32, 1)));
 
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", param.name}),
-                           std::move(params));
-
-  mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
 
   ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
-  ASSERT_TRUE(gen().EmitImportFunction(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen().EmitCall(pre(), out(), &expr)) << gen().error();
   EXPECT_EQ(result(), std::string(param.hlsl_name) + "(1)");
 }
 INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
                          HlslImportData_SingleIntParamTest,
-                         testing::Values(HlslImportData{"sabs", "abs"},
-                                         HlslImportData{"ssign", "sign"}));
+                         testing::Values(HlslImportData{"abs", "abs"}));
 
 using HlslImportData_DualParamTest =
     TestHelperBase<testing::TestWithParam<HlslImportData>>;
@@ -151,14 +129,12 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 2.f)));
 
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", param.name}),
-                           std::move(params));
-
-  mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
 
   ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
-  ASSERT_TRUE(gen().EmitImportFunction(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen().EmitCall(pre(), out(), &expr)) << gen().error();
   EXPECT_EQ(result(),
             std::string(param.hlsl_name) + "(1.00000000f, 2.00000000f)");
 }
@@ -166,10 +142,8 @@
                          HlslImportData_DualParamTest,
                          testing::Values(HlslImportData{"atan2", "atan2"},
                                          HlslImportData{"distance", "distance"},
-                                         HlslImportData{"fmax", "max"},
-                                         HlslImportData{"fmin", "min"},
-                                         HlslImportData{"nmax", "max"},
-                                         HlslImportData{"nmin", "min"},
+                                         HlslImportData{"max", "max"},
+                                         HlslImportData{"min", "min"},
                                          HlslImportData{"pow", "pow"},
                                          HlslImportData{"reflect", "reflect"},
                                          HlslImportData{"step", "step"}));
@@ -203,14 +177,12 @@
   params.push_back(std::make_unique<ast::TypeConstructorExpression>(
       &vec, std::move(type_params)));
 
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", param.name}),
-                           std::move(params));
-
-  mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
 
   ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
-  ASSERT_TRUE(gen().EmitImportFunction(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen().EmitCall(pre(), out(), &expr)) << gen().error();
   EXPECT_EQ(result(),
             std::string(param.hlsl_name) +
                 "(vector<float, 3>(1.00000000f, 2.00000000f, 3.00000000f), "
@@ -233,22 +205,18 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::SintLiteral>(&i32, 2)));
 
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", param.name}),
-                           std::move(params));
-
-  mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
 
   ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
-  ASSERT_TRUE(gen().EmitImportFunction(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen().EmitCall(pre(), out(), &expr)) << gen().error();
   EXPECT_EQ(result(), std::string(param.hlsl_name) + "(1, 2)");
 }
 INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
                          HlslImportData_DualParam_Int_Test,
-                         testing::Values(HlslImportData{"smax", "max"},
-                                         HlslImportData{"smin", "min"},
-                                         HlslImportData{"umax", "max"},
-                                         HlslImportData{"umin", "min"}));
+                         testing::Values(HlslImportData{"max", "max"},
+                                         HlslImportData{"min", "min"}));
 
 using HlslImportData_TripleParamTest =
     TestHelperBase<testing::TestWithParam<HlslImportData>>;
@@ -265,25 +233,22 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 3.f)));
 
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", param.name}),
-                           std::move(params));
-
-  mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
 
   ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
-  ASSERT_TRUE(gen().EmitImportFunction(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen().EmitCall(pre(), out(), &expr)) << gen().error();
   EXPECT_EQ(result(), std::string(param.hlsl_name) +
                           "(1.00000000f, 2.00000000f, 3.00000000f)");
 }
 INSTANTIATE_TEST_SUITE_P(
     HlslGeneratorImplTest_Import,
     HlslImportData_TripleParamTest,
-    testing::Values(HlslImportData{"faceforward", "faceforward"},
+    testing::Values(HlslImportData{"faceForward", "faceforward"},
                     HlslImportData{"fma", "fma"},
-                    HlslImportData{"fclamp", "clamp"},
-                    HlslImportData{"nclamp", "clamp"},
-                    HlslImportData{"smoothstep", "smoothstep"}));
+                    HlslImportData{"clamp", "clamp"},
+                    HlslImportData{"smoothStep", "smoothstep"}));
 
 TEST_F(HlslGeneratorImplTest_Import, DISABLED_HlslImportData_FMix) {
   FAIL();
@@ -304,20 +269,17 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::SintLiteral>(&i32, 3)));
 
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", param.name}),
-                           std::move(params));
-
-  mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
 
   ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
-  ASSERT_TRUE(gen().EmitImportFunction(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen().EmitCall(pre(), out(), &expr)) << gen().error();
   EXPECT_EQ(result(), std::string(param.hlsl_name) + "(1, 2, 3)");
 }
 INSTANTIATE_TEST_SUITE_P(HlslGeneratorImplTest_Import,
                          HlslImportData_TripleParam_Int_Test,
-                         testing::Values(HlslImportData{"sclamp", "clamp"},
-                                         HlslImportData{"uclamp", "clamp"}));
+                         testing::Values(HlslImportData{"clamp", "clamp"}));
 
 TEST_F(HlslGeneratorImplTest_Import, HlslImportData_Determinant) {
   ast::type::F32Type f32;
@@ -329,17 +291,16 @@
   ast::ExpressionList params;
   params.push_back(std::make_unique<ast::IdentifierExpression>("var"));
 
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", "determinant"}),
-                           std::move(params));
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>("determinant"),
+      std::move(params));
 
   mod()->AddGlobalVariable(std::move(var));
-  mod()->AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
 
   // Register the global
   ASSERT_TRUE(td().Determine()) << td().error();
   ASSERT_TRUE(td().DetermineResultType(&expr)) << td().error();
-  ASSERT_TRUE(gen().EmitImportFunction(pre(), out(), &expr)) << gen().error();
+  ASSERT_TRUE(gen().EmitCall(pre(), out(), &expr)) << gen().error();
   EXPECT_EQ(result(), std::string("determinant(var)"));
 }
 
diff --git a/src/writer/hlsl/generator_impl_intrinsic_test.cc b/src/writer/hlsl/generator_impl_intrinsic_test.cc
index 0455e97..8b46c7f 100644
--- a/src/writer/hlsl/generator_impl_intrinsic_test.cc
+++ b/src/writer/hlsl/generator_impl_intrinsic_test.cc
@@ -29,36 +29,36 @@
 using HlslGeneratorImplTest_Intrinsic = TestHelper;
 
 struct IntrinsicData {
-  const char* name;
+  ast::Intrinsic intrinsic;
   const char* hlsl_name;
 };
 inline std::ostream& operator<<(std::ostream& out, IntrinsicData data) {
-  out << data.name;
+  out << data.hlsl_name;
   return out;
 }
 using HlslIntrinsicTest = TestHelperBase<testing::TestWithParam<IntrinsicData>>;
 TEST_P(HlslIntrinsicTest, Emit) {
   auto param = GetParam();
-  EXPECT_EQ(gen().generate_intrinsic_name(param.name), param.hlsl_name);
+  EXPECT_EQ(gen().generate_intrinsic_name(param.intrinsic), param.hlsl_name);
 }
 INSTANTIATE_TEST_SUITE_P(
     HlslGeneratorImplTest_Intrinsic,
     HlslIntrinsicTest,
-    testing::Values(IntrinsicData{"any", "any"},
-                    IntrinsicData{"all", "all"},
-                    IntrinsicData{"dot", "dot"},
-                    IntrinsicData{"dpdx", "ddx"},
-                    IntrinsicData{"dpdx_coarse", "ddx_coarse"},
-                    IntrinsicData{"dpdx_fine", "ddx_fine"},
-                    IntrinsicData{"dpdy", "ddy"},
-                    IntrinsicData{"dpdy_coarse", "ddy_coarse"},
-                    IntrinsicData{"dpdy_fine", "ddy_fine"},
-                    IntrinsicData{"fwidth", "fwidth"},
-                    IntrinsicData{"fwidth_coarse", "fwidth"},
-                    IntrinsicData{"fwidth_fine", "fwidth"},
-                    IntrinsicData{"is_finite", "isfinite"},
-                    IntrinsicData{"is_inf", "isinf"},
-                    IntrinsicData{"is_nan", "isnan"}));
+    testing::Values(IntrinsicData{ast::Intrinsic::kAny, "any"},
+                    IntrinsicData{ast::Intrinsic::kAll, "all"},
+                    IntrinsicData{ast::Intrinsic::kDot, "dot"},
+                    IntrinsicData{ast::Intrinsic::kDpdx, "ddx"},
+                    IntrinsicData{ast::Intrinsic::kDpdxCoarse, "ddx_coarse"},
+                    IntrinsicData{ast::Intrinsic::kDpdxFine, "ddx_fine"},
+                    IntrinsicData{ast::Intrinsic::kDpdy, "ddy"},
+                    IntrinsicData{ast::Intrinsic::kDpdyCoarse, "ddy_coarse"},
+                    IntrinsicData{ast::Intrinsic::kDpdyFine, "ddy_fine"},
+                    IntrinsicData{ast::Intrinsic::kFwidth, "fwidth"},
+                    IntrinsicData{ast::Intrinsic::kFwidthCoarse, "fwidth"},
+                    IntrinsicData{ast::Intrinsic::kFwidthFine, "fwidth"},
+                    IntrinsicData{ast::Intrinsic::kIsFinite, "isfinite"},
+                    IntrinsicData{ast::Intrinsic::kIsInf, "isinf"},
+                    IntrinsicData{ast::Intrinsic::kIsNan, "isnan"}));
 
 TEST_F(HlslGeneratorImplTest_Intrinsic, DISABLED_Intrinsic_IsNormal) {
   FAIL();
@@ -101,7 +101,7 @@
 }
 
 TEST_F(HlslGeneratorImplTest_Intrinsic, Intrinsic_Bad_Name) {
-  EXPECT_EQ(gen().generate_intrinsic_name("unknown name"), "");
+  EXPECT_EQ(gen().generate_intrinsic_name(ast::Intrinsic::kNone), "");
 }
 
 TEST_F(HlslGeneratorImplTest_Intrinsic, Intrinsic_Call) {
@@ -112,6 +112,8 @@
   ast::CallExpression call(std::make_unique<ast::IdentifierExpression>("dot"),
                            std::move(params));
 
+  ASSERT_TRUE(td().DetermineResultType(&call)) << td().error();
+
   gen().increment_indent();
   ASSERT_TRUE(gen().EmitExpression(pre(), out(), &call)) << gen().error();
   EXPECT_EQ(result(), "  dot(param1, param2)");
diff --git a/src/writer/msl/generator_impl.cc b/src/writer/msl/generator_impl.cc
index c6d45f7..c4f2329 100644
--- a/src/writer/msl/generator_impl.cc
+++ b/src/writer/msl/generator_impl.cc
@@ -14,7 +14,6 @@
 
 #include "src/writer/msl/generator_impl.h"
 
-#include "spirv/unified1/GLSL.std.450.h"
 #include "src/ast/array_accessor_expression.h"
 #include "src/ast/as_expression.h"
 #include "src/ast/assignment_statement.h"
@@ -33,7 +32,6 @@
 #include "src/ast/function.h"
 #include "src/ast/identifier_expression.h"
 #include "src/ast/if_statement.h"
-#include "src/ast/intrinsic.h"
 #include "src/ast/location_decoration.h"
 #include "src/ast/loop_statement.h"
 #include "src/ast/member_accessor_expression.h"
@@ -409,38 +407,44 @@
   return name;
 }
 
-std::string GeneratorImpl::generate_intrinsic_name(const std::string& name) {
-  if (name == "any") {
+std::string GeneratorImpl::generate_intrinsic_name(ast::Intrinsic intrinsic) {
+  if (intrinsic == ast::Intrinsic::kAny) {
     return "any";
   }
-  if (name == "all") {
+  if (intrinsic == ast::Intrinsic::kAll) {
     return "all";
   }
-  if (name == "dot") {
+  if (intrinsic == ast::Intrinsic::kDot) {
     return "dot";
   }
-  if (name == "is_finite") {
+  if (intrinsic == ast::Intrinsic::kIsFinite) {
     return "isfinite";
   }
-  if (name == "is_inf") {
+  if (intrinsic == ast::Intrinsic::kIsInf) {
     return "isinf";
   }
-  if (name == "is_nan") {
+  if (intrinsic == ast::Intrinsic::kIsNan) {
     return "isnan";
   }
-  if (name == "is_normal") {
+  if (intrinsic == ast::Intrinsic::kIsNormal) {
     return "isnormal";
   }
-  if (name == "select") {
+  if (intrinsic == ast::Intrinsic::kSelect) {
     return "select";
   }
-  if (name == "dpdy" || name == "dpdy_fine" || name == "dpdy_coarse") {
+  if (intrinsic == ast::Intrinsic::kDpdy ||
+      intrinsic == ast::Intrinsic::kDpdyFine ||
+      intrinsic == ast::Intrinsic::kDpdyCoarse) {
     return "dfdy";
   }
-  if (name == "dpdx" || name == "dpdx_fine" || name == "dpdx_coarse") {
+  if (intrinsic == ast::Intrinsic::kDpdx ||
+      intrinsic == ast::Intrinsic::kDpdxFine ||
+      intrinsic == ast::Intrinsic::kDpdxCoarse) {
     return "dfdx";
   }
-  if (name == "fwidth" || name == "fwidth_fine" || name == "fwidth_coarse") {
+  if (intrinsic == ast::Intrinsic::kFwidth ||
+      intrinsic == ast::Intrinsic::kFwidthFine ||
+      intrinsic == ast::Intrinsic::kFwidthCoarse) {
     return "fwidth";
   }
   return "";
@@ -453,9 +457,9 @@
   }
 
   auto* ident = expr->func()->AsIdentifier();
-  if (!ident->has_path() && ast::intrinsic::IsIntrinsic(ident->name())) {
+  if (ident->IsIntrinsic()) {
     const auto& params = expr->params();
-    if (ident->name() == "outer_product") {
+    if (ident->intrinsic() == ast::Intrinsic::kOuterProduct) {
       error_ = "outer_product not supported yet";
       return false;
       // TODO(dsinclair): This gets tricky. We need to generate two variables to
@@ -508,11 +512,15 @@
 
       // out_ << ")";
     } else {
-      auto name = generate_intrinsic_name(ident->name());
+      auto name = generate_intrinsic_name(ident->intrinsic());
       if (name.empty()) {
-        error_ = "unable to determine intrinsic name for intrinsic: " +
-                 ident->name();
-        return false;
+        if (ast::intrinsic::IsTextureIntrinsic(ident->intrinsic())) {
+          error_ = "Textures not implemented yet";
+          return false;
+        }
+        if (!EmitBuiltinName(ident)) {
+          return false;
+        }
       }
 
       make_indent();
@@ -535,191 +543,69 @@
     return true;
   }
 
-  if (!ident->has_path()) {
-    auto name = ident->name();
-    auto it = ep_func_name_remapped_.find(current_ep_name_ + "_" + name);
-    if (it != ep_func_name_remapped_.end()) {
-      name = it->second;
-    }
-
-    auto* func = module_->FindFunctionByName(ident->name());
-    if (func == nullptr) {
-      error_ = "Unable to find function: " + name;
-      return false;
-    }
-
-    out_ << name << "(";
-
-    bool first = true;
-    if (has_referenced_in_var_needing_struct(func)) {
-      auto var_name = current_ep_var_name(VarType::kIn);
-      if (!var_name.empty()) {
-        out_ << var_name;
-        first = false;
-      }
-    }
-    if (has_referenced_out_var_needing_struct(func)) {
-      auto var_name = current_ep_var_name(VarType::kOut);
-      if (!var_name.empty()) {
-        if (!first) {
-          out_ << ", ";
-        }
-        first = false;
-        out_ << var_name;
-      }
-    }
-
-    for (const auto& data : func->referenced_builtin_variables()) {
-      auto* var = data.first;
-      if (var->storage_class() != ast::StorageClass::kInput) {
-        continue;
-      }
-      if (!first) {
-        out_ << ", ";
-      }
-      first = false;
-      out_ << var->name();
-    }
-
-    for (const auto& data : func->referenced_uniform_variables()) {
-      auto* var = data.first;
-      if (!first) {
-        out_ << ", ";
-      }
-      first = false;
-      out_ << var->name();
-    }
-
-    for (const auto& data : func->referenced_storagebuffer_variables()) {
-      auto* var = data.first;
-      if (!first) {
-        out_ << ", ";
-      }
-      first = false;
-      out_ << var->name();
-    }
-
-    const auto& params = expr->params();
-    for (const auto& param : params) {
-      if (!first) {
-        out_ << ", ";
-      }
-      first = false;
-
-      if (!EmitExpression(param.get())) {
-        return false;
-      }
-    }
-
-    out_ << ")";
-  } else {
-    return EmitImportFunction(expr);
-  }
-  return true;
-}
-
-bool GeneratorImpl::EmitImportFunction(ast::CallExpression* expr) {
-  auto* ident = expr->func()->AsIdentifier();
-
-  auto* imp = module_->FindImportByName(ident->path());
-  if (imp == nullptr) {
-    error_ = "unable to find import for " + ident->path();
-    return 0;
-  }
-  auto id = imp->GetIdForMethod(ident->name());
-  if (id == 0) {
-    error_ = "unable to lookup: " + ident->name() + " in " + ident->path();
+  auto name = ident->name();
+  auto it = ep_func_name_remapped_.find(current_ep_name_ + "_" + name);
+  if (it != ep_func_name_remapped_.end()) {
+    name = it->second;
   }
 
-  out_ << "metal::";
-  switch (id) {
-    case GLSLstd450Acos:
-    case GLSLstd450Acosh:
-    case GLSLstd450Asin:
-    case GLSLstd450Asinh:
-    case GLSLstd450Atan:
-    case GLSLstd450Atan2:
-    case GLSLstd450Atanh:
-    case GLSLstd450Ceil:
-    case GLSLstd450Cos:
-    case GLSLstd450Cosh:
-    case GLSLstd450Cross:
-    case GLSLstd450Determinant:
-    case GLSLstd450Distance:
-    case GLSLstd450Exp:
-    case GLSLstd450Exp2:
-    case GLSLstd450FAbs:
-    case GLSLstd450FaceForward:
-    case GLSLstd450Floor:
-    case GLSLstd450Fma:
-    case GLSLstd450Fract:
-    case GLSLstd450Length:
-    case GLSLstd450Log:
-    case GLSLstd450Log2:
-    case GLSLstd450Normalize:
-    case GLSLstd450Pow:
-    case GLSLstd450Reflect:
-    case GLSLstd450Round:
-    case GLSLstd450Sin:
-    case GLSLstd450Sinh:
-    case GLSLstd450SmoothStep:
-    case GLSLstd450Sqrt:
-    case GLSLstd450Step:
-    case GLSLstd450Tan:
-    case GLSLstd450Tanh:
-    case GLSLstd450Trunc:
-      out_ << ident->name();
-      break;
-    case GLSLstd450InverseSqrt:
-      out_ << "rsqrt";
-      break;
-    case GLSLstd450FMax:
-    case GLSLstd450NMax:
-      out_ << "fmax";
-      break;
-    case GLSLstd450FMin:
-    case GLSLstd450NMin:
-      out_ << "fmin";
-      break;
-    case GLSLstd450FMix:
-      out_ << "mix";
-      break;
-    case GLSLstd450FSign:
-      out_ << "sign";
-      break;
-    case GLSLstd450SAbs:
-      out_ << "abs";
-      break;
-    case GLSLstd450SMax:
-    case GLSLstd450UMax:
-      out_ << "max";
-      break;
-    case GLSLstd450SMin:
-    case GLSLstd450UMin:
-      out_ << "min";
-      break;
-    case GLSLstd450FClamp:
-    case GLSLstd450SClamp:
-    case GLSLstd450NClamp:
-    case GLSLstd450UClamp:
-      out_ << "clamp";
-      break;
-    // TODO(dsinclair): Determine mappings for the following
-    case GLSLstd450Degrees:
-    case GLSLstd450FindILsb:
-    case GLSLstd450FindUMsb:
-    case GLSLstd450FindSMsb:
-    case GLSLstd450InterpolateAtCentroid:
-    case GLSLstd450MatrixInverse:
-    case GLSLstd450Radians:
-    case GLSLstd450RoundEven:
-    case GLSLstd450SSign:
-      error_ = "Unknown import method: " + ident->name();
-      return false;
+  auto* func = module_->FindFunctionByName(ident->name());
+  if (func == nullptr) {
+    error_ = "Unable to find function: " + name;
+    return false;
   }
 
-  out_ << "(";
+  out_ << name << "(";
+
   bool first = true;
+  if (has_referenced_in_var_needing_struct(func)) {
+    auto var_name = current_ep_var_name(VarType::kIn);
+    if (!var_name.empty()) {
+      out_ << var_name;
+      first = false;
+    }
+  }
+  if (has_referenced_out_var_needing_struct(func)) {
+    auto var_name = current_ep_var_name(VarType::kOut);
+    if (!var_name.empty()) {
+      if (!first) {
+        out_ << ", ";
+      }
+      first = false;
+      out_ << var_name;
+    }
+  }
+
+  for (const auto& data : func->referenced_builtin_variables()) {
+    auto* var = data.first;
+    if (var->storage_class() != ast::StorageClass::kInput) {
+      continue;
+    }
+    if (!first) {
+      out_ << ", ";
+    }
+    first = false;
+    out_ << var->name();
+  }
+
+  for (const auto& data : func->referenced_uniform_variables()) {
+    auto* var = data.first;
+    if (!first) {
+      out_ << ", ";
+    }
+    first = false;
+    out_ << var->name();
+  }
+
+  for (const auto& data : func->referenced_storagebuffer_variables()) {
+    auto* var = data.first;
+    if (!first) {
+      out_ << ", ";
+    }
+    first = false;
+    out_ << var->name();
+  }
+
   const auto& params = expr->params();
   for (const auto& param : params) {
     if (!first) {
@@ -731,11 +617,89 @@
       return false;
     }
   }
+
   out_ << ")";
 
   return true;
 }
 
+bool GeneratorImpl::EmitBuiltinName(ast::IdentifierExpression* ident) {
+  out_ << "metal::";
+  switch (ident->intrinsic()) {
+    case ast::Intrinsic::kAcos:
+    case ast::Intrinsic::kAsin:
+    case ast::Intrinsic::kAtan:
+    case ast::Intrinsic::kAtan2:
+    case ast::Intrinsic::kCeil:
+    case ast::Intrinsic::kCos:
+    case ast::Intrinsic::kCosh:
+    case ast::Intrinsic::kCross:
+    case ast::Intrinsic::kDeterminant:
+    case ast::Intrinsic::kDistance:
+    case ast::Intrinsic::kExp:
+    case ast::Intrinsic::kExp2:
+    case ast::Intrinsic::kFloor:
+    case ast::Intrinsic::kFma:
+    case ast::Intrinsic::kFract:
+    case ast::Intrinsic::kLength:
+    case ast::Intrinsic::kLog:
+    case ast::Intrinsic::kLog2:
+    case ast::Intrinsic::kMix:
+    case ast::Intrinsic::kNormalize:
+    case ast::Intrinsic::kPow:
+    case ast::Intrinsic::kReflect:
+    case ast::Intrinsic::kRound:
+    case ast::Intrinsic::kSin:
+    case ast::Intrinsic::kSinh:
+    case ast::Intrinsic::kSqrt:
+    case ast::Intrinsic::kStep:
+    case ast::Intrinsic::kTan:
+    case ast::Intrinsic::kTanh:
+    case ast::Intrinsic::kTrunc:
+    case ast::Intrinsic::kSign:
+    case ast::Intrinsic::kClamp:
+      out_ << ident->name();
+      break;
+    case ast::Intrinsic::kAbs:
+      if (ident->result_type()->IsF32()) {
+        out_ << "fabs";
+      } else if (ident->result_type()->IsU32() ||
+                 ident->result_type()->IsI32()) {
+        out_ << "abs";
+      }
+      break;
+    case ast::Intrinsic::kMax:
+      if (ident->result_type()->IsF32()) {
+        out_ << "fmax";
+      } else if (ident->result_type()->IsU32() ||
+                 ident->result_type()->IsI32()) {
+        out_ << "max";
+      }
+      break;
+    case ast::Intrinsic::kMin:
+      if (ident->result_type()->IsF32()) {
+        out_ << "fmin";
+      } else if (ident->result_type()->IsU32() ||
+                 ident->result_type()->IsI32()) {
+        out_ << "min";
+      }
+      break;
+    case ast::Intrinsic::kFaceForward:
+      out_ << "faceforward";
+      break;
+    case ast::Intrinsic::kSmoothStep:
+      out_ << "smoothstep";
+      break;
+    case ast::Intrinsic::kInverseSqrt:
+      out_ << "rsqrt";
+      break;
+    default:
+      error_ = "Unknown import method: " + ident->name();
+      return false;
+  }
+  return true;
+}
+
 bool GeneratorImpl::EmitCase(ast::CaseStatement* stmt) {
   make_indent();
 
@@ -1402,12 +1366,6 @@
 
 bool GeneratorImpl::EmitIdentifier(ast::IdentifierExpression* expr) {
   auto* ident = expr->AsIdentifier();
-  if (ident->has_path()) {
-    // TODO(dsinclair): Handle identifier with path
-    error_ = "Identifier paths not handled yet.";
-    return false;
-  }
-
   ast::Variable* var = nullptr;
   if (global_variables_.get(ident->name(), &var)) {
     if (global_is_in_struct(var)) {
diff --git a/src/writer/msl/generator_impl.h b/src/writer/msl/generator_impl.h
index 459cac5..68f5574 100644
--- a/src/writer/msl/generator_impl.h
+++ b/src/writer/msl/generator_impl.h
@@ -19,6 +19,7 @@
 #include <string>
 #include <unordered_map>
 
+#include "src/ast/intrinsic.h"
 #include "src/ast/literal.h"
 #include "src/ast/module.h"
 #include "src/ast/scalar_constructor_expression.h"
@@ -150,10 +151,10 @@
   /// @param stmt the statement to emit
   /// @returns true if the statement was successfully emitted
   bool EmitIf(ast::IfStatement* stmt);
-  /// Handles genreating an import expression
-  /// @param expr the expression
-  /// @returns true if the expression was successfully emitted.
-  bool EmitImportFunction(ast::CallExpression* expr);
+  /// Handles generating a builtin name
+  /// @param ident the identifier to build the name from
+  /// @returns true if the name was successfully emitted.
+  bool EmitBuiltinName(ast::IdentifierExpression* ident);
   /// Handles a literal
   /// @param lit the literal to emit
   /// @returns true if the literal was successfully emitted
@@ -230,9 +231,9 @@
   /// @returns the name
   std::string generate_name(const std::string& prefix);
   /// Generates an intrinsic name from the given name
-  /// @param name the name to convert to an intrinsic
+  /// @param intrinsic the intrinsic to convert to an method name
   /// @returns the intrinsic name or blank on error
-  std::string generate_intrinsic_name(const std::string& name);
+  std::string generate_intrinsic_name(ast::Intrinsic intrinsic);
 
   /// Checks if the global variable is in an input or output struct
   /// @param var the variable to check
diff --git a/src/writer/msl/generator_impl_identifier_test.cc b/src/writer/msl/generator_impl_identifier_test.cc
index 7c7bc19..2e07db5 100644
--- a/src/writer/msl/generator_impl_identifier_test.cc
+++ b/src/writer/msl/generator_impl_identifier_test.cc
@@ -24,16 +24,7 @@
 
 using MslGeneratorImplTest = testing::Test;
 
-TEST_F(MslGeneratorImplTest, DISABLED_EmitExpression_Identifier) {
-  ast::IdentifierExpression i(std::vector<std::string>{"std", "glsl"});
-
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitExpression(&i)) << g.error();
-  EXPECT_EQ(g.result(), "std::glsl");
-}
-
-TEST_F(MslGeneratorImplTest, EmitIdentifierExpression_Single) {
+TEST_F(MslGeneratorImplTest, EmitIdentifierExpression) {
   ast::IdentifierExpression i("foo");
 
   ast::Module m;
@@ -51,16 +42,6 @@
   EXPECT_EQ(g.result(), "virtual_tint_0");
 }
 
-// TODO(dsinclair): Handle import names
-TEST_F(MslGeneratorImplTest, DISABLED_EmitIdentifierExpression_MultipleNames) {
-  ast::IdentifierExpression i({"std", "glsl", "init"});
-
-  ast::Module m;
-  GeneratorImpl g(&m);
-  ASSERT_TRUE(g.EmitExpression(&i)) << g.error();
-  EXPECT_EQ(g.result(), "std::glsl::init");
-}
-
 }  // namespace
 }  // namespace msl
 }  // namespace writer
diff --git a/src/writer/msl/generator_impl_import_test.cc b/src/writer/msl/generator_impl_import_test.cc
index fcf0d50..358838f 100644
--- a/src/writer/msl/generator_impl_import_test.cc
+++ b/src/writer/msl/generator_impl_import_test.cc
@@ -57,46 +57,41 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
 
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", param.name}),
-                           std::move(params));
+  auto ident = std::make_unique<ast::IdentifierExpression>(param.name);
+  auto* ident_ptr = ident.get();
+
+  ast::CallExpression call(std::move(ident), std::move(params));
 
   Context ctx;
   ast::Module mod;
   TypeDeterminer td(&ctx, &mod);
-  mod.AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
 
-  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+  // The call type determination will set the intrinsic data for the ident
+  ASSERT_TRUE(td.DetermineResultType(&call)) << td.error();
 
   GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitImportFunction(&expr)) << g.error();
-  EXPECT_EQ(g.result(),
-            std::string("metal::") + param.msl_name + "(1.00000000f)");
+  ASSERT_TRUE(g.EmitBuiltinName(ident_ptr)) << g.error();
+  EXPECT_EQ(g.result(), std::string("metal::") + param.msl_name);
 }
 INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
                          MslImportData_SingleParamTest,
-                         testing::Values(MslImportData{"acos", "acos"},
-                                         MslImportData{"acosh", "acosh"},
+                         testing::Values(MslImportData{"abs", "fabs"},
+                                         MslImportData{"acos", "acos"},
                                          MslImportData{"asin", "asin"},
-                                         MslImportData{"asinh", "asinh"},
                                          MslImportData{"atan", "atan"},
-                                         MslImportData{"atanh", "atanh"},
+                                         MslImportData{"ceil", "ceil"},
                                          MslImportData{"cos", "cos"},
                                          MslImportData{"cosh", "cosh"},
-                                         MslImportData{"ceil", "ceil"},
                                          MslImportData{"exp", "exp"},
                                          MslImportData{"exp2", "exp2"},
-                                         MslImportData{"fabs", "fabs"},
                                          MslImportData{"floor", "floor"},
                                          MslImportData{"fract", "fract"},
-                                         MslImportData{"inversesqrt", "rsqrt"},
+                                         MslImportData{"inverseSqrt", "rsqrt"},
                                          MslImportData{"length", "length"},
                                          MslImportData{"log", "log"},
                                          MslImportData{"log2", "log2"},
-                                         MslImportData{"normalize",
-                                                       "normalize"},
                                          MslImportData{"round", "round"},
-                                         MslImportData{"fsign", "sign"},
+                                         MslImportData{"sign", "sign"},
                                          MslImportData{"sin", "sin"},
                                          MslImportData{"sinh", "sinh"},
                                          MslImportData{"sqrt", "sqrt"},
@@ -111,19 +106,17 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::SintLiteral>(&i32, 1)));
 
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", "sabs"}),
+  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>("abs"),
                            std::move(params));
 
   Context ctx;
   ast::Module mod;
   TypeDeterminer td(&ctx, &mod);
-  mod.AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
   GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitImportFunction(&expr)) << g.error();
+  ASSERT_TRUE(g.EmitCall(&expr)) << g.error();
   EXPECT_EQ(g.result(), R"(metal::abs(1))");
 }
 
@@ -139,19 +132,18 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 2.f)));
 
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", param.name}),
-                           std::move(params));
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
 
   Context ctx;
   ast::Module mod;
   TypeDeterminer td(&ctx, &mod);
-  mod.AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
   GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitImportFunction(&expr)) << g.error();
+  ASSERT_TRUE(g.EmitCall(&expr)) << g.error();
   EXPECT_EQ(g.result(), std::string("metal::") + param.msl_name +
                             "(1.00000000f, 2.00000000f)");
 }
@@ -159,10 +151,8 @@
                          MslImportData_DualParamTest,
                          testing::Values(MslImportData{"atan2", "atan2"},
                                          MslImportData{"distance", "distance"},
-                                         MslImportData{"fmax", "fmax"},
-                                         MslImportData{"fmin", "fmin"},
-                                         MslImportData{"nmax", "fmax"},
-                                         MslImportData{"nmin", "fmin"},
+                                         MslImportData{"max", "fmax"},
+                                         MslImportData{"min", "fmin"},
                                          MslImportData{"pow", "pow"},
                                          MslImportData{"reflect", "reflect"},
                                          MslImportData{"step", "step"}));
@@ -196,19 +186,18 @@
   params.push_back(std::make_unique<ast::TypeConstructorExpression>(
       &vec, std::move(type_params)));
 
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", param.name}),
-                           std::move(params));
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
 
   Context ctx;
   ast::Module mod;
   TypeDeterminer td(&ctx, &mod);
-  mod.AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
   GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitImportFunction(&expr)) << g.error();
+  ASSERT_TRUE(g.EmitCall(&expr)) << g.error();
   EXPECT_EQ(g.result(), std::string("metal::") + param.msl_name +
                             "(float3(1.00000000f, 2.00000000f, 3.00000000f), "
                             "float3(4.00000000f, 5.00000000f, 6.00000000f))");
@@ -229,27 +218,24 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::SintLiteral>(&i32, 2)));
 
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", param.name}),
-                           std::move(params));
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
 
   Context ctx;
   ast::Module mod;
   TypeDeterminer td(&ctx, &mod);
-  mod.AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
   GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitImportFunction(&expr)) << g.error();
+  ASSERT_TRUE(g.EmitCall(&expr)) << g.error();
   EXPECT_EQ(g.result(), std::string("metal::") + param.msl_name + "(1, 2)");
 }
 INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
                          MslImportData_DualParam_Int_Test,
-                         testing::Values(MslImportData{"smax", "max"},
-                                         MslImportData{"smin", "min"},
-                                         MslImportData{"umax", "max"},
-                                         MslImportData{"umin", "min"}));
+                         testing::Values(MslImportData{"max", "max"},
+                                         MslImportData{"min", "min"}));
 
 using MslImportData_TripleParamTest = testing::TestWithParam<MslImportData>;
 TEST_P(MslImportData_TripleParamTest, FloatScalar) {
@@ -265,31 +251,29 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 3.f)));
 
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", param.name}),
-                           std::move(params));
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
 
   Context ctx;
   ast::Module mod;
   TypeDeterminer td(&ctx, &mod);
-  mod.AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
   GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitImportFunction(&expr)) << g.error();
+  ASSERT_TRUE(g.EmitCall(&expr)) << g.error();
   EXPECT_EQ(g.result(), std::string("metal::") + param.msl_name +
                             "(1.00000000f, 2.00000000f, 3.00000000f)");
 }
 INSTANTIATE_TEST_SUITE_P(
     MslGeneratorImplTest,
     MslImportData_TripleParamTest,
-    testing::Values(MslImportData{"faceforward", "faceforward"},
+    testing::Values(MslImportData{"faceForward", "faceforward"},
                     MslImportData{"fma", "fma"},
-                    MslImportData{"fclamp", "clamp"},
-                    MslImportData{"fmix", "mix"},
-                    MslImportData{"nclamp", "clamp"},
-                    MslImportData{"smoothstep", "smoothstep"}));
+                    MslImportData{"mix", "mix"},
+                    MslImportData{"clamp", "clamp"},
+                    MslImportData{"smoothStep", "smoothstep"}));
 
 using MslImportData_TripleParam_Int_Test =
     testing::TestWithParam<MslImportData>;
@@ -306,25 +290,24 @@
   params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::SintLiteral>(&i32, 3)));
 
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", param.name}),
-                           std::move(params));
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
 
   Context ctx;
   ast::Module mod;
   TypeDeterminer td(&ctx, &mod);
-  mod.AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
 
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
   GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitImportFunction(&expr)) << g.error();
+  ASSERT_TRUE(g.EmitCall(&expr)) << g.error();
   EXPECT_EQ(g.result(), std::string("metal::") + param.msl_name + "(1, 2, 3)");
 }
 INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
                          MslImportData_TripleParam_Int_Test,
-                         testing::Values(MslImportData{"sclamp", "clamp"},
-                                         MslImportData{"uclamp", "clamp"}));
+                         testing::Values(MslImportData{"clamp", "clamp"},
+                                         MslImportData{"clamp", "clamp"}));
 
 TEST_F(MslGeneratorImplTest, MslImportData_Determinant) {
   ast::type::F32Type f32;
@@ -336,14 +319,13 @@
   ast::ExpressionList params;
   params.push_back(std::make_unique<ast::IdentifierExpression>("var"));
 
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", "determinant"}),
-                           std::move(params));
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>("determinant"),
+      std::move(params));
 
   Context ctx;
   ast::Module mod;
   mod.AddGlobalVariable(std::move(var));
-  mod.AddImport(std::make_unique<ast::Import>("GLSL.std.450", "std"));
 
   TypeDeterminer td(&ctx, &mod);
   // Register the global
@@ -351,7 +333,7 @@
   ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
 
   GeneratorImpl g(&mod);
-  ASSERT_TRUE(g.EmitImportFunction(&expr)) << g.error();
+  ASSERT_TRUE(g.EmitCall(&expr)) << g.error();
   EXPECT_EQ(g.result(), std::string("metal::determinant(var)"));
 }
 
diff --git a/src/writer/msl/generator_impl_intrinsic_test.cc b/src/writer/msl/generator_impl_intrinsic_test.cc
index b52955c..ed09571 100644
--- a/src/writer/msl/generator_impl_intrinsic_test.cc
+++ b/src/writer/msl/generator_impl_intrinsic_test.cc
@@ -30,11 +30,11 @@
 using MslGeneratorImplTest = testing::Test;
 
 struct IntrinsicData {
-  const char* name;
+  ast::Intrinsic intrinsic;
   const char* msl_name;
 };
 inline std::ostream& operator<<(std::ostream& out, IntrinsicData data) {
-  out << data.name;
+  out << data.msl_name;
   return out;
 }
 using MslIntrinsicTest = testing::TestWithParam<IntrinsicData>;
@@ -43,28 +43,28 @@
 
   ast::Module m;
   GeneratorImpl g(&m);
-  EXPECT_EQ(g.generate_intrinsic_name(param.name), param.msl_name);
+  EXPECT_EQ(g.generate_intrinsic_name(param.intrinsic), param.msl_name);
 }
-INSTANTIATE_TEST_SUITE_P(MslGeneratorImplTest,
-                         MslIntrinsicTest,
-                         testing::Values(IntrinsicData{"any", "any"},
-                                         IntrinsicData{"all", "all"},
-                                         IntrinsicData{"dot", "dot"},
-                                         IntrinsicData{"dpdx", "dfdx"},
-                                         IntrinsicData{"dpdx_coarse", "dfdx"},
-                                         IntrinsicData{"dpdx_fine", "dfdx"},
-                                         IntrinsicData{"dpdy", "dfdy"},
-                                         IntrinsicData{"dpdy_coarse", "dfdy"},
-                                         IntrinsicData{"dpdy_fine", "dfdy"},
-                                         IntrinsicData{"fwidth", "fwidth"},
-                                         IntrinsicData{"fwidth_coarse",
-                                                       "fwidth"},
-                                         IntrinsicData{"fwidth_fine", "fwidth"},
-                                         IntrinsicData{"is_finite", "isfinite"},
-                                         IntrinsicData{"is_inf", "isinf"},
-                                         IntrinsicData{"is_nan", "isnan"},
-                                         IntrinsicData{"is_normal", "isnormal"},
-                                         IntrinsicData{"select", "select"}));
+INSTANTIATE_TEST_SUITE_P(
+    MslGeneratorImplTest,
+    MslIntrinsicTest,
+    testing::Values(IntrinsicData{ast::Intrinsic::kAny, "any"},
+                    IntrinsicData{ast::Intrinsic::kAll, "all"},
+                    IntrinsicData{ast::Intrinsic::kDot, "dot"},
+                    IntrinsicData{ast::Intrinsic::kDpdx, "dfdx"},
+                    IntrinsicData{ast::Intrinsic::kDpdxCoarse, "dfdx"},
+                    IntrinsicData{ast::Intrinsic::kDpdxFine, "dfdx"},
+                    IntrinsicData{ast::Intrinsic::kDpdy, "dfdy"},
+                    IntrinsicData{ast::Intrinsic::kDpdyCoarse, "dfdy"},
+                    IntrinsicData{ast::Intrinsic::kDpdyFine, "dfdy"},
+                    IntrinsicData{ast::Intrinsic::kFwidth, "fwidth"},
+                    IntrinsicData{ast::Intrinsic::kFwidthCoarse, "fwidth"},
+                    IntrinsicData{ast::Intrinsic::kFwidthFine, "fwidth"},
+                    IntrinsicData{ast::Intrinsic::kIsFinite, "isfinite"},
+                    IntrinsicData{ast::Intrinsic::kIsInf, "isinf"},
+                    IntrinsicData{ast::Intrinsic::kIsNan, "isnan"},
+                    IntrinsicData{ast::Intrinsic::kIsNormal, "isnormal"},
+                    IntrinsicData{ast::Intrinsic::kSelect, "select"}));
 
 TEST_F(MslGeneratorImplTest, DISABLED_Intrinsic_OuterProduct) {
   ast::type::F32Type f32;
@@ -106,7 +106,7 @@
 TEST_F(MslGeneratorImplTest, Intrinsic_Bad_Name) {
   ast::Module m;
   GeneratorImpl g(&m);
-  EXPECT_EQ(g.generate_intrinsic_name("unknown name"), "");
+  EXPECT_EQ(g.generate_intrinsic_name(ast::Intrinsic::kNone), "");
 }
 
 TEST_F(MslGeneratorImplTest, Intrinsic_Call) {
@@ -117,7 +117,11 @@
   ast::CallExpression call(std::make_unique<ast::IdentifierExpression>("dot"),
                            std::move(params));
 
+  Context ctx;
   ast::Module m;
+  TypeDeterminer td(&ctx, &m);
+  ASSERT_TRUE(td.DetermineResultType(&call)) << td.error();
+
   GeneratorImpl g(&m);
   g.increment_indent();
   ASSERT_TRUE(g.EmitExpression(&call)) << g.error();
diff --git a/src/writer/spirv/builder.cc b/src/writer/spirv/builder.cc
index 8bfd9a1..529286f 100644
--- a/src/writer/spirv/builder.cc
+++ b/src/writer/spirv/builder.cc
@@ -17,6 +17,7 @@
 #include <sstream>
 #include <utility>
 
+#include "spirv/unified1/GLSL.std.450.h"
 #include "spirv/unified1/spirv.h"
 #include "src/ast/array_accessor_expression.h"
 #include "src/ast/as_expression.h"
@@ -68,11 +69,15 @@
 #include "src/ast/unary_op_expression.h"
 #include "src/ast/variable_decl_statement.h"
 
+#include <iostream>
+
 namespace tint {
 namespace writer {
 namespace spirv {
 namespace {
 
+const char kGLSLstd450[] = "GLSL.std.450";
+
 uint32_t size_of(const InstructionList& instructions) {
   uint32_t size = 0;
   for (const auto& inst : instructions)
@@ -147,6 +152,119 @@
   return type->IsMatrix() ? type->AsMatrix() : nullptr;
 }
 
+uint32_t intrinsic_to_glsl_method(ast::type::Type* type,
+                                  ast::Intrinsic intrinsic) {
+  switch (intrinsic) {
+    case ast::Intrinsic::kAbs:
+      if (type->is_float_scalar_or_vector()) {
+        return GLSLstd450FAbs;
+      } else {
+        return GLSLstd450SAbs;
+      }
+    case ast::Intrinsic::kAcos:
+      return GLSLstd450Acos;
+    case ast::Intrinsic::kAsin:
+      return GLSLstd450Asin;
+    case ast::Intrinsic::kAtan:
+      return GLSLstd450Atan;
+    case ast::Intrinsic::kAtan2:
+      return GLSLstd450Atan2;
+    case ast::Intrinsic::kCeil:
+      return GLSLstd450Ceil;
+    case ast::Intrinsic::kClamp:
+      if (type->is_float_scalar_or_vector()) {
+        return GLSLstd450NClamp;
+      } else if (type->is_unsigned_scalar_or_vector()) {
+        return GLSLstd450UClamp;
+      } else {
+        return GLSLstd450SClamp;
+      }
+    case ast::Intrinsic::kCos:
+      return GLSLstd450Cos;
+    case ast::Intrinsic::kCosh:
+      return GLSLstd450Cosh;
+    case ast::Intrinsic::kCross:
+      return GLSLstd450Cross;
+    case ast::Intrinsic::kDeterminant:
+      return GLSLstd450Determinant;
+    case ast::Intrinsic::kDistance:
+      return GLSLstd450Distance;
+    case ast::Intrinsic::kExp:
+      return GLSLstd450Exp;
+    case ast::Intrinsic::kExp2:
+      return GLSLstd450Exp2;
+    case ast::Intrinsic::kFaceForward:
+      return GLSLstd450FaceForward;
+    case ast::Intrinsic::kFloor:
+      return GLSLstd450Floor;
+    case ast::Intrinsic::kFma:
+      return GLSLstd450Fma;
+    case ast::Intrinsic::kFract:
+      return GLSLstd450Fract;
+    case ast::Intrinsic::kFrexp:
+      return GLSLstd450Frexp;
+    case ast::Intrinsic::kInverseSqrt:
+      return GLSLstd450InverseSqrt;
+    case ast::Intrinsic::kLdexp:
+      return GLSLstd450Ldexp;
+    case ast::Intrinsic::kLength:
+      return GLSLstd450Length;
+    case ast::Intrinsic::kLog:
+      return GLSLstd450Log;
+    case ast::Intrinsic::kLog2:
+      return GLSLstd450Log2;
+    case ast::Intrinsic::kMax:
+      if (type->is_float_scalar_or_vector()) {
+        return GLSLstd450NMax;
+      } else if (type->is_unsigned_scalar_or_vector()) {
+        return GLSLstd450UMax;
+      } else {
+        return GLSLstd450SMax;
+      }
+    case ast::Intrinsic::kMin:
+      if (type->is_float_scalar_or_vector()) {
+        return GLSLstd450NMin;
+      } else if (type->is_unsigned_scalar_or_vector()) {
+        return GLSLstd450UMin;
+      } else {
+        return GLSLstd450SMin;
+      }
+    case ast::Intrinsic::kMix:
+      return GLSLstd450FMix;
+    case ast::Intrinsic::kModf:
+      return GLSLstd450Modf;
+    case ast::Intrinsic::kNormalize:
+      return GLSLstd450Normalize;
+    case ast::Intrinsic::kPow:
+      return GLSLstd450Pow;
+    case ast::Intrinsic::kReflect:
+      return GLSLstd450Reflect;
+    case ast::Intrinsic::kRound:
+      return GLSLstd450Round;
+    case ast::Intrinsic::kSign:
+      return GLSLstd450FSign;
+    case ast::Intrinsic::kSin:
+      return GLSLstd450Sin;
+    case ast::Intrinsic::kSinh:
+      return GLSLstd450Sinh;
+    case ast::Intrinsic::kSmoothStep:
+      return GLSLstd450SmoothStep;
+    case ast::Intrinsic::kSqrt:
+      return GLSLstd450Sqrt;
+    case ast::Intrinsic::kStep:
+      return GLSLstd450Step;
+    case ast::Intrinsic::kTan:
+      return GLSLstd450Tan;
+    case ast::Intrinsic::kTanh:
+      return GLSLstd450Tanh;
+    case ast::Intrinsic::kTrunc:
+      return GLSLstd450Trunc;
+    default:
+      break;
+  }
+  return 0;
+}
+
 }  // namespace
 
 Builder::AccessorInfo::AccessorInfo() : source_id(0), source_type(nullptr) {}
@@ -165,10 +283,6 @@
   push_preamble(spv::Op::OpExtension,
                 {Operand::String("SPV_KHR_vulkan_memory_model")});
 
-  for (const auto& imp : mod_->imports()) {
-    GenerateImport(imp.get());
-  }
-
   push_preamble(spv::Op::OpMemoryModel,
                 {Operand::Int(SpvAddressingModelLogical),
                  Operand::Int(SpvMemoryModelVulkanKHR)});
@@ -853,18 +967,6 @@
 uint32_t Builder::GenerateIdentifierExpression(
     ast::IdentifierExpression* expr) {
   uint32_t val = 0;
-  if (expr->has_path()) {
-    auto* imp = mod_->FindImportByName(expr->path());
-    if (imp == nullptr) {
-      error_ = "unable to find import for " + expr->path();
-      return 0;
-    }
-    val = imp->GetIdForMethod(expr->name());
-    if (val == 0) {
-      error_ = "unable to lookup: " + expr->name() + " in " + expr->path();
-    }
-    return val;
-  }
   if (scope_stack_.get(expr->name(), &val)) {
     return val;
   }
@@ -920,14 +1022,18 @@
   return result_id;
 }
 
-void Builder::GenerateImport(ast::Import* imp) {
+void Builder::GenerateGLSLstd450Import() {
+  if (import_name_to_id_.find(kGLSLstd450) != import_name_to_id_.end()) {
+    return;
+  }
+
   auto result = result_op();
   auto id = result.to_i();
 
   push_preamble(spv::Op::OpExtInstImport,
-                {result, Operand::String(imp->path())});
+                {result, Operand::String(kGLSLstd450)});
 
-  import_name_to_id_[imp->name()] = id;
+  import_name_to_id_[kGLSLstd450] = id;
 }
 
 uint32_t Builder::GenerateConstructorExpression(
@@ -1361,8 +1467,8 @@
 
   auto* ident = expr->func()->AsIdentifier();
 
-  if (!ident->has_path() && ast::intrinsic::IsIntrinsic(ident->name())) {
-    return GenerateIntrinsic(ident->name(), expr);
+  if (ident->IsIntrinsic()) {
+    return GenerateIntrinsic(ident, expr);
   }
 
   auto type_id = GenerateTypeIfNeeded(expr->func()->result_type());
@@ -1373,45 +1479,14 @@
   auto result = result_op();
   auto result_id = result.to_i();
 
-  spv::Op op = spv::Op::OpNop;
   OperandList ops = {Operand::Int(type_id), result};
 
-  // Handle regular function calls
-  if (!ident->has_path()) {
-    auto func_id = func_name_to_id_[ident->name()];
-    if (func_id == 0) {
-      error_ = "unable to find called function: " + ident->name();
-      return 0;
-    }
-    ops.push_back(Operand::Int(func_id));
-
-    op = spv::Op::OpFunctionCall;
-  } else {
-    // Imported function call
-    auto set_iter = import_name_to_id_.find(ident->path());
-    if (set_iter == import_name_to_id_.end()) {
-      error_ = "unknown import " + ident->path();
-      return 0;
-    }
-    auto set_id = set_iter->second;
-
-    auto* imp = mod_->FindImportByName(ident->path());
-    if (imp == nullptr) {
-      error_ = "unknown import " + ident->path();
-      return 0;
-    }
-
-    auto inst_id = imp->GetIdForMethod(ident->name());
-    if (inst_id == 0) {
-      error_ = "unknown method " + ident->name();
-      return 0;
-    }
-
-    ops.push_back(Operand::Int(set_id));
-    ops.push_back(Operand::Int(inst_id));
-
-    op = spv::Op::OpExtInst;
+  auto func_id = func_name_to_id_[ident->name()];
+  if (func_id == 0) {
+    error_ = "unable to find called function: " + ident->name();
+    return 0;
   }
+  ops.push_back(Operand::Int(func_id));
 
   for (const auto& param : expr->params()) {
     auto id = GenerateExpression(param.get());
@@ -1422,12 +1497,12 @@
     ops.push_back(Operand::Int(id));
   }
 
-  push_function_inst(op, std::move(ops));
+  push_function_inst(spv::Op::OpFunctionCall, std::move(ops));
 
   return result_id;
 }
 
-uint32_t Builder::GenerateIntrinsic(const std::string& name,
+uint32_t Builder::GenerateIntrinsic(ast::IdentifierExpression* ident,
                                     ast::CallExpression* call) {
   auto result = result_op();
   auto result_id = result.to_i();
@@ -1438,6 +1513,76 @@
   }
 
   OperandList params = {Operand::Int(result_type_id), result};
+
+  auto intrinsic = ident->intrinsic();
+  if (ast::intrinsic::IsFineDerivative(intrinsic) ||
+      ast::intrinsic::IsCoarseDerivative(intrinsic)) {
+    push_capability(SpvCapabilityDerivativeControl);
+  }
+
+  spv::Op op = spv::Op::OpNop;
+  if (intrinsic == ast::Intrinsic::kAny) {
+    op = spv::Op::OpAny;
+  } else if (intrinsic == ast::Intrinsic::kAll) {
+    op = spv::Op::OpAll;
+  } else if (intrinsic == ast::Intrinsic::kCountOneBits) {
+    op = spv::Op::OpBitCount;
+  } else if (intrinsic == ast::Intrinsic::kDot) {
+    op = spv::Op::OpDot;
+  } else if (intrinsic == ast::Intrinsic::kDpdx) {
+    op = spv::Op::OpDPdx;
+  } else if (intrinsic == ast::Intrinsic::kDpdxCoarse) {
+    op = spv::Op::OpDPdxCoarse;
+  } else if (intrinsic == ast::Intrinsic::kDpdxFine) {
+    op = spv::Op::OpDPdxFine;
+  } else if (intrinsic == ast::Intrinsic::kDpdy) {
+    op = spv::Op::OpDPdy;
+  } else if (intrinsic == ast::Intrinsic::kDpdyCoarse) {
+    op = spv::Op::OpDPdyCoarse;
+  } else if (intrinsic == ast::Intrinsic::kDpdyFine) {
+    op = spv::Op::OpDPdyFine;
+  } else if (intrinsic == ast::Intrinsic::kFwidth) {
+    op = spv::Op::OpFwidth;
+  } else if (intrinsic == ast::Intrinsic::kFwidthCoarse) {
+    op = spv::Op::OpFwidthCoarse;
+  } else if (intrinsic == ast::Intrinsic::kFwidthFine) {
+    op = spv::Op::OpFwidthFine;
+  } else if (intrinsic == ast::Intrinsic::kIsInf) {
+    op = spv::Op::OpIsInf;
+  } else if (intrinsic == ast::Intrinsic::kIsNan) {
+    op = spv::Op::OpIsNan;
+  } else if (intrinsic == ast::Intrinsic::kOuterProduct) {
+    op = spv::Op::OpOuterProduct;
+  } else if (intrinsic == ast::Intrinsic::kReverseBits) {
+    op = spv::Op::OpBitReverse;
+  } else if (intrinsic == ast::Intrinsic::kSelect) {
+    op = spv::Op::OpSelect;
+  } else if (!ast::intrinsic::IsTextureIntrinsic(intrinsic)) {
+    GenerateGLSLstd450Import();
+
+    auto set_iter = import_name_to_id_.find(kGLSLstd450);
+    if (set_iter == import_name_to_id_.end()) {
+      error_ = std::string("unknown import ") + kGLSLstd450;
+      return 0;
+    }
+    auto set_id = set_iter->second;
+    auto inst_id =
+        intrinsic_to_glsl_method(ident->result_type(), ident->intrinsic());
+    if (inst_id == 0) {
+      error_ = "unknown method " + ident->name();
+      return 0;
+    }
+
+    params.push_back(Operand::Int(set_id));
+    params.push_back(Operand::Int(inst_id));
+
+    op = spv::Op::OpExtInst;
+  }
+  if (!ast::intrinsic::IsTextureIntrinsic(intrinsic) && op == spv::Op::OpNop) {
+    error_ = "unable to determine operator for: " + ident->name();
+    return 0;
+  }
+
   for (const auto& p : call->params()) {
     auto val_id = GenerateExpression(p.get());
     if (val_id == 0) {
@@ -1448,59 +1593,16 @@
     params.push_back(Operand::Int(val_id));
   }
 
-  if (ast::intrinsic::IsTextureOperationIntrinsic(name)) {
-    return GenerateTextureIntrinsic(name, call, result_id, params);
+  if (ast::intrinsic::IsTextureIntrinsic(intrinsic)) {
+    return GenerateTextureIntrinsic(ident, call, result_id, params);
   }
 
-  if (ast::intrinsic::IsFineDerivative(name) ||
-      ast::intrinsic::IsCoarseDerivative(name)) {
-    push_capability(SpvCapabilityDerivativeControl);
-  }
-
-  spv::Op op = spv::Op::OpNop;
-  if (name == "any") {
-    op = spv::Op::OpAny;
-  } else if (name == "all") {
-    op = spv::Op::OpAll;
-  } else if (name == "dot") {
-    op = spv::Op::OpDot;
-  } else if (name == "dpdx") {
-    op = spv::Op::OpDPdx;
-  } else if (name == "dpdxCoarse") {
-    op = spv::Op::OpDPdxCoarse;
-  } else if (name == "dpdxFine") {
-    op = spv::Op::OpDPdxFine;
-  } else if (name == "dpdy") {
-    op = spv::Op::OpDPdy;
-  } else if (name == "dpdyCoarse") {
-    op = spv::Op::OpDPdyCoarse;
-  } else if (name == "dpdyFine") {
-    op = spv::Op::OpDPdyFine;
-  } else if (name == "fwidth") {
-    op = spv::Op::OpFwidth;
-  } else if (name == "fwidthCoarse") {
-    op = spv::Op::OpFwidthCoarse;
-  } else if (name == "fwidthFine") {
-    op = spv::Op::OpFwidthFine;
-  } else if (name == "isInf") {
-    op = spv::Op::OpIsInf;
-  } else if (name == "isNan") {
-    op = spv::Op::OpIsNan;
-  } else if (name == "outerProduct") {
-    op = spv::Op::OpOuterProduct;
-  } else if (name == "select") {
-    op = spv::Op::OpSelect;
-  }
-  if (op == spv::Op::OpNop) {
-    error_ = "unable to determine operator for: " + name;
-    return 0;
-  }
   push_function_inst(op, params);
 
   return result_id;
 }
 
-uint32_t Builder::GenerateTextureIntrinsic(const std::string& name,
+uint32_t Builder::GenerateTextureIntrinsic(ast::IdentifierExpression* ident,
                                            ast::CallExpression* call,
                                            uint32_t result_id,
                                            OperandList wgsl_params) {
@@ -1512,7 +1614,7 @@
 
   // TODO: Remove the LOD param from textureLoad on storage textures when
   // https://github.com/gpuweb/gpuweb/pull/1032 gets merged.
-  if (name == "textureLoad") {
+  if (ident->intrinsic() == ast::Intrinsic::kTextureLoad) {
     std::vector<Operand> spirv_params = {
         std::move(wgsl_params[0]), std::move(wgsl_params[1]),
         std::move(wgsl_params[2]), std::move(wgsl_params[3])};
@@ -1538,17 +1640,17 @@
                                         std::move(wgsl_params[3]))),
       std::move(wgsl_params[4])};
 
-  if (name == "textureSample") {
+  if (ident->intrinsic() == ast::Intrinsic::kTextureSample) {
     op = spv::Op::OpImageSampleImplicitLod;
-  } else if (name == "textureSampleLevel") {
+  } else if (ident->intrinsic() == ast::Intrinsic::kTextureSampleLevel) {
     op = spv::Op::OpImageSampleExplicitLod;
     spirv_params.push_back(Operand::Int(SpvImageOperandsLodMask));
     spirv_params.push_back(std::move(wgsl_params[5]));
-  } else if (name == "textureSampleBias") {
+  } else if (ident->intrinsic() == ast::Intrinsic::kTextureSampleBias) {
     op = spv::Op::OpImageSampleImplicitLod;
     spirv_params.push_back(Operand::Int(SpvImageOperandsBiasMask));
     spirv_params.push_back(std::move(wgsl_params[5]));
-  } else if (name == "textureSampleCompare") {
+  } else if (ident->intrinsic() == ast::Intrinsic::kTextureSampleCompare) {
     op = spv::Op::OpImageSampleDrefExplicitLod;
     spirv_params.push_back(std::move(wgsl_params[5]));
 
@@ -1558,7 +1660,7 @@
     spirv_params.push_back(Operand::Int(GenerateLiteralIfNeeded(&float_0)));
   }
   if (op == spv::Op::OpNop) {
-    error_ = "unable to determine operator for: " + name;
+    error_ = "unable to determine operator for: " + ident->name();
     return 0;
   }
   push_function_inst(op, spirv_params);
diff --git a/src/writer/spirv/builder.h b/src/writer/spirv/builder.h
index 2a467fc..7b809f3 100644
--- a/src/writer/spirv/builder.h
+++ b/src/writer/spirv/builder.h
@@ -247,8 +247,7 @@
   /// @returns true on success
   bool GenerateIfStatement(ast::IfStatement* stmt);
   /// Generates an import instruction
-  /// @param imp the import
-  void GenerateImport(ast::Import* imp);
+  void GenerateGLSLstd450Import();
   /// Generates a constructor expression
   /// @param expr the expression to generate
   /// @param is_global_init set true if this is a global variable constructor
@@ -283,19 +282,19 @@
   /// @returns the expression ID on success or 0 otherwise
   uint32_t GenerateCallExpression(ast::CallExpression* expr);
   /// Generates an intrinsic call
-  /// @param name the intrinsic name
+  /// @param ident the intrinsic expression
   /// @param call the call expression
   /// @returns the expression ID on success or 0 otherwise
-  uint32_t GenerateIntrinsic(const std::string& name,
+  uint32_t GenerateIntrinsic(ast::IdentifierExpression* ident,
                              ast::CallExpression* call);
   /// Generates a texture intrinsic call
-  /// @param name the texture intrinsic name
+  /// @param ident the texture intrinsic
   /// @param call the call expression
   /// @param result_id result ID of the texture instruction
   /// @param wgsl_params SPIR-V arguments for WGSL-specific intrinsic's call
   /// parameters
   /// @returns the expression ID on success or 0 otherwise
-  uint32_t GenerateTextureIntrinsic(const std::string& name,
+  uint32_t GenerateTextureIntrinsic(ast::IdentifierExpression* ident,
                                     ast::CallExpression* call,
                                     uint32_t result_id,
                                     OperandList wgsl_params);
diff --git a/src/writer/spirv/builder_call_test.cc b/src/writer/spirv/builder_call_test.cc
index 5b78cbf..2544a48 100644
--- a/src/writer/spirv/builder_call_test.cc
+++ b/src/writer/spirv/builder_call_test.cc
@@ -38,98 +38,6 @@
 
 using BuilderTest = testing::Test;
 
-TEST_F(BuilderTest, Call_GLSLMethod) {
-  ast::type::F32Type f32;
-  ast::type::VoidType void_type;
-
-  ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
-      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
-
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", "round"}),
-                           std::move(params));
-
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-
-  auto imp = std::make_unique<ast::Import>("GLSL.std.450", "std");
-  auto* glsl = imp.get();
-  mod.AddImport(std::move(imp));
-
-  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
-
-  ast::Function func("a_func", {}, &void_type);
-
-  Builder b(&mod);
-  b.GenerateImport(glsl);
-  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
-
-  EXPECT_EQ(b.GenerateCallExpression(&expr), 7u) << b.error();
-  EXPECT_EQ(DumpBuilder(b), R"(%1 = OpExtInstImport "GLSL.std.450"
-OpName %4 "a_func"
-%3 = OpTypeVoid
-%2 = OpTypeFunction %3
-%6 = OpTypeFloat 32
-%8 = OpConstant %6 1
-%4 = OpFunction %3 None %2
-%5 = OpLabel
-%7 = OpExtInst %6 %1 Round %8
-OpFunctionEnd
-)");
-}
-
-TEST_F(BuilderTest, Call_GLSLMethod_WithLoad) {
-  ast::type::F32Type f32;
-  ast::type::VoidType void_type;
-
-  auto var = std::make_unique<ast::Variable>("ident",
-                                             ast::StorageClass::kPrivate, &f32);
-
-  ast::ExpressionList params;
-  params.push_back(std::make_unique<ast::IdentifierExpression>("ident"));
-
-  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(
-                               std::vector<std::string>{"std", "round"}),
-                           std::move(params));
-
-  Context ctx;
-  ast::Module mod;
-  TypeDeterminer td(&ctx, &mod);
-  td.RegisterVariableForTesting(var.get());
-
-  auto imp = std::make_unique<ast::Import>("GLSL.std.450", "std");
-  auto* glsl = imp.get();
-  mod.AddImport(std::move(imp));
-
-  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
-
-  ast::Function func("a_func", {}, &void_type);
-
-  Builder b(&mod);
-  b.GenerateImport(glsl);
-  ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
-  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
-
-  EXPECT_EQ(b.GenerateCallExpression(&expr), 10u) << b.error();
-  EXPECT_EQ(DumpBuilder(b), R"(%1 = OpExtInstImport "GLSL.std.450"
-OpName %2 "ident"
-OpName %8 "a_func"
-%4 = OpTypeFloat 32
-%3 = OpTypePointer Private %4
-%5 = OpConstantNull %4
-%2 = OpVariable %3 Private %5
-%7 = OpTypeVoid
-%6 = OpTypeFunction %7
-%8 = OpFunction %7 None %6
-%9 = OpLabel
-%11 = OpLoad %4 %2
-%10 = OpExtInst %4 %1 Round %11
-OpFunctionEnd
-)");
-}
-
 TEST_F(BuilderTest, Expression_Call) {
   ast::type::F32Type f32;
   ast::type::VoidType void_type;
diff --git a/src/writer/spirv/builder_intrinsic_test.cc b/src/writer/spirv/builder_intrinsic_test.cc
index 1fbc36b..f2d374b 100644
--- a/src/writer/spirv/builder_intrinsic_test.cc
+++ b/src/writer/spirv/builder_intrinsic_test.cc
@@ -30,7 +30,9 @@
 #include "src/ast/type/sampler_type.h"
 #include "src/ast/type/u32_type.h"
 #include "src/ast/type/vector_type.h"
+#include "src/ast/type/void_type.h"
 #include "src/ast/type_constructor_expression.h"
+#include "src/ast/uint_literal.h"
 #include "src/ast/variable.h"
 #include "src/context.h"
 #include "src/type_determiner.h"
@@ -181,6 +183,164 @@
                          testing::Values(IntrinsicData{"isNan", "OpIsNan"},
                                          IntrinsicData{"isInf", "OpIsInf"}));
 
+using IntrinsicIntTest = testing::TestWithParam<IntrinsicData>;
+TEST_P(IntrinsicIntTest, Call_SInt_Scalar) {
+  auto param = GetParam();
+
+  ast::type::I32Type i32;
+
+  auto var =
+      std::make_unique<ast::Variable>("v", ast::StorageClass::kPrivate, &i32);
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::IdentifierExpression>("v"));
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+  td.RegisterVariableForTesting(var.get());
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  Builder b(&mod);
+  b.push_function(Function{});
+  ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeInt 32 1
+%2 = OpTypePointer Private %3
+%4 = OpConstantNull %3
+%1 = OpVariable %2 Private %4
+)");
+  EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
+            R"(%6 = OpLoad %3 %1
+%5 = )" + param.op +
+                " %3 %6\n");
+}
+
+TEST_P(IntrinsicIntTest, Call_SInt_Vector) {
+  auto param = GetParam();
+
+  ast::type::I32Type i32;
+  ast::type::VectorType vec3(&i32, 3);
+
+  auto var =
+      std::make_unique<ast::Variable>("v", ast::StorageClass::kPrivate, &vec3);
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::IdentifierExpression>("v"));
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+  td.RegisterVariableForTesting(var.get());
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  Builder b(&mod);
+  b.push_function(Function{});
+  ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 6u) << b.error();
+  EXPECT_EQ(DumpInstructions(b.types()), R"(%4 = OpTypeInt 32 1
+%3 = OpTypeVector %4 3
+%2 = OpTypePointer Private %3
+%5 = OpConstantNull %3
+%1 = OpVariable %2 Private %5
+)");
+  EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
+            R"(%7 = OpLoad %3 %1
+%6 = )" + param.op +
+                " %3 %7\n");
+}
+
+TEST_P(IntrinsicIntTest, Call_UInt_Scalar) {
+  auto param = GetParam();
+
+  ast::type::U32Type u32;
+
+  auto var =
+      std::make_unique<ast::Variable>("v", ast::StorageClass::kPrivate, &u32);
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::IdentifierExpression>("v"));
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+  td.RegisterVariableForTesting(var.get());
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  Builder b(&mod);
+  b.push_function(Function{});
+  ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeInt 32 0
+%2 = OpTypePointer Private %3
+%4 = OpConstantNull %3
+%1 = OpVariable %2 Private %4
+)");
+  EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
+            R"(%6 = OpLoad %3 %1
+%5 = )" + param.op +
+                " %3 %6\n");
+}
+
+TEST_P(IntrinsicIntTest, Call_UInt_Vector) {
+  auto param = GetParam();
+
+  ast::type::U32Type u32;
+  ast::type::VectorType vec3(&u32, 3);
+
+  auto var =
+      std::make_unique<ast::Variable>("v", ast::StorageClass::kPrivate, &vec3);
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::IdentifierExpression>("v"));
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+  td.RegisterVariableForTesting(var.get());
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  Builder b(&mod);
+  b.push_function(Function{});
+  ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 6u) << b.error();
+  EXPECT_EQ(DumpInstructions(b.types()), R"(%4 = OpTypeInt 32 0
+%3 = OpTypeVector %4 3
+%2 = OpTypePointer Private %3
+%5 = OpConstantNull %3
+%1 = OpVariable %2 Private %5
+)");
+  EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()),
+            R"(%7 = OpLoad %3 %1
+%6 = )" + param.op +
+                " %3 %7\n");
+}
+INSTANTIATE_TEST_SUITE_P(
+    BuilderTest,
+    IntrinsicIntTest,
+    testing::Values(IntrinsicData{"countOneBits", "OpBitCount"},
+                    IntrinsicData{"reverseBits", "OpBitReverse"}));
+
 TEST_F(BuilderTest, Call_Dot) {
   ast::type::F32Type f32;
   ast::type::VectorType vec3(&f32, 3);
@@ -1215,6 +1375,1347 @@
 )");
 }
 
+TEST_F(BuilderTest, Call_GLSLMethod_WithLoad) {
+  ast::type::F32Type f32;
+  ast::type::VoidType void_type;
+
+  auto var = std::make_unique<ast::Variable>("ident",
+                                             ast::StorageClass::kPrivate, &f32);
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::IdentifierExpression>("ident"));
+
+  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>("round"),
+                           std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+  td.RegisterVariableForTesting(var.get());
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 9u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%10 = OpExtInstImport "GLSL.std.450"
+OpName %1 "ident"
+OpName %7 "a_func"
+%3 = OpTypeFloat 32
+%2 = OpTypePointer Private %3
+%4 = OpConstantNull %3
+%1 = OpVariable %2 Private %4
+%6 = OpTypeVoid
+%5 = OpTypeFunction %6
+%7 = OpFunction %6 None %5
+%8 = OpLabel
+%11 = OpLoad %3 %1
+%9 = OpExtInst %3 %10 Round %11
+OpFunctionEnd
+)");
+}
+
+using Intrinsic_Builtin_SingleParam_Float_Test =
+    testing::TestWithParam<IntrinsicData>;
+TEST_P(Intrinsic_Builtin_SingleParam_Float_Test, Call_Scalar) {
+  auto param = GetParam();
+
+  ast::type::F32Type f32;
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%7 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%6 = OpTypeFloat 32
+%8 = OpConstant %6 1
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %7 )" + param.op +
+                                R"( %8
+OpFunctionEnd
+)");
+}
+
+TEST_P(Intrinsic_Builtin_SingleParam_Float_Test, Call_Vector) {
+  auto param = GetParam();
+
+  ast::type::F32Type f32;
+  ast::type::VectorType vec(&f32, 2);
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList vals;
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  ast::ExpressionList params;
+  params.push_back(
+      std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%8 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%7 = OpTypeFloat 32
+%6 = OpTypeVector %7 2
+%9 = OpConstant %7 1
+%10 = OpConstantComposite %6 %9 %9
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %8 )" + param.op +
+                                R"( %10
+OpFunctionEnd
+)");
+}
+INSTANTIATE_TEST_SUITE_P(BuilderTest,
+                         Intrinsic_Builtin_SingleParam_Float_Test,
+                         testing::Values(IntrinsicData{"abs", "FAbs"},
+                                         IntrinsicData{"acos", "Acos"},
+                                         IntrinsicData{"asin", "Asin"},
+                                         IntrinsicData{"atan", "Atan"},
+                                         IntrinsicData{"ceil", "Ceil"},
+                                         IntrinsicData{"cos", "Cos"},
+                                         IntrinsicData{"cosh", "Cosh"},
+                                         IntrinsicData{"exp", "Exp"},
+                                         IntrinsicData{"exp2", "Exp2"},
+                                         IntrinsicData{"floor", "Floor"},
+                                         IntrinsicData{"fract", "Fract"},
+                                         IntrinsicData{"inverseSqrt",
+                                                       "InverseSqrt"},
+                                         IntrinsicData{"log", "Log"},
+                                         IntrinsicData{"log2", "Log2"},
+                                         IntrinsicData{"round", "Round"},
+                                         IntrinsicData{"sign", "FSign"},
+                                         IntrinsicData{"sin", "Sin"},
+                                         IntrinsicData{"sinh", "Sinh"},
+                                         IntrinsicData{"sqrt", "Sqrt"},
+                                         IntrinsicData{"tan", "Tan"},
+                                         IntrinsicData{"tanh", "Tanh"},
+                                         IntrinsicData{"trunc", "Trunc"}));
+
+TEST_F(BuilderTest, Call_Length_Scalar) {
+  ast::type::F32Type f32;
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>("length"), std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%7 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%6 = OpTypeFloat 32
+%8 = OpConstant %6 1
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %7 Length %8
+OpFunctionEnd
+)");
+}
+
+TEST_F(BuilderTest, Call_Length_Vector) {
+  ast::type::F32Type f32;
+  ast::type::VectorType vec(&f32, 2);
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList vals;
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  ast::ExpressionList params;
+  params.push_back(
+      std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>("length"), std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%7 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%6 = OpTypeFloat 32
+%8 = OpTypeVector %6 2
+%9 = OpConstant %6 1
+%10 = OpConstantComposite %8 %9 %9
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %7 Length %10
+OpFunctionEnd
+)");
+}
+
+TEST_F(BuilderTest, Call_Normalize) {
+  ast::type::F32Type f32;
+  ast::type::VectorType vec(&f32, 2);
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList vals;
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  ast::ExpressionList params;
+  params.push_back(
+      std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>("normalize"),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%8 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%7 = OpTypeFloat 32
+%6 = OpTypeVector %7 2
+%9 = OpConstant %7 1
+%10 = OpConstantComposite %6 %9 %9
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %8 Normalize %10
+OpFunctionEnd
+)");
+}
+
+using Intrinsic_Builtin_DualParam_Float_Test =
+    testing::TestWithParam<IntrinsicData>;
+TEST_P(Intrinsic_Builtin_DualParam_Float_Test, Call_Scalar) {
+  auto param = GetParam();
+
+  ast::type::F32Type f32;
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%7 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%6 = OpTypeFloat 32
+%8 = OpConstant %6 1
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %7 )" + param.op +
+                                R"( %8 %8
+OpFunctionEnd
+)");
+}
+
+TEST_P(Intrinsic_Builtin_DualParam_Float_Test, Call_Vector) {
+  auto param = GetParam();
+
+  ast::type::F32Type f32;
+  ast::type::VectorType vec(&f32, 2);
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList vals_1;
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  ast::ExpressionList vals_2;
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_1)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_2)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%8 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%7 = OpTypeFloat 32
+%6 = OpTypeVector %7 2
+%9 = OpConstant %7 1
+%10 = OpConstantComposite %6 %9 %9
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %8 )" + param.op +
+                                R"( %10 %10
+OpFunctionEnd
+)");
+}
+INSTANTIATE_TEST_SUITE_P(BuilderTest,
+                         Intrinsic_Builtin_DualParam_Float_Test,
+                         testing::Values(IntrinsicData{"atan2", "Atan2"},
+                                         IntrinsicData{"max", "NMax"},
+                                         IntrinsicData{"min", "NMin"},
+                                         IntrinsicData{"pow", "Pow"},
+                                         IntrinsicData{"reflect", "Reflect"},
+                                         IntrinsicData{"step", "Step"}));
+
+TEST_F(BuilderTest, Call_Distance_Scalar) {
+  ast::type::F32Type f32;
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>("distance"),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%7 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%6 = OpTypeFloat 32
+%8 = OpConstant %6 1
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %7 Distance %8 %8
+OpFunctionEnd
+)");
+}
+
+TEST_F(BuilderTest, Call_Distance_Vector) {
+  ast::type::F32Type f32;
+  ast::type::VectorType vec(&f32, 2);
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList vals_1;
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  ast::ExpressionList vals_2;
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_1)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_2)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>("distance"),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%7 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%6 = OpTypeFloat 32
+%8 = OpTypeVector %6 2
+%9 = OpConstant %6 1
+%10 = OpConstantComposite %8 %9 %9
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %7 Distance %10 %10
+OpFunctionEnd
+)");
+}
+
+TEST_F(BuilderTest, Call_Cross) {
+  ast::type::F32Type f32;
+  ast::type::VectorType vec(&f32, 3);
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList vals_1;
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  ast::ExpressionList vals_2;
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_1)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_2)));
+
+  ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>("cross"),
+                           std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%8 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%7 = OpTypeFloat 32
+%6 = OpTypeVector %7 3
+%9 = OpConstant %7 1
+%10 = OpConstantComposite %6 %9 %9 %9
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %8 Cross %10 %10
+OpFunctionEnd
+)");
+}
+
+using Intrinsic_Builtin_ThreeParam_Float_Test =
+    testing::TestWithParam<IntrinsicData>;
+TEST_P(Intrinsic_Builtin_ThreeParam_Float_Test, Call_Scalar) {
+  auto param = GetParam();
+
+  ast::type::F32Type f32;
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%7 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%6 = OpTypeFloat 32
+%8 = OpConstant %6 1
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %7 )" + param.op +
+                                R"( %8 %8 %8
+OpFunctionEnd
+)");
+}
+
+TEST_P(Intrinsic_Builtin_ThreeParam_Float_Test, Call_Vector) {
+  auto param = GetParam();
+
+  ast::type::F32Type f32;
+  ast::type::VectorType vec(&f32, 2);
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList vals_1;
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  ast::ExpressionList vals_2;
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  ast::ExpressionList vals_3;
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::FloatLiteral>(&f32, 1.f)));
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_1)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_2)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_3)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%8 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%7 = OpTypeFloat 32
+%6 = OpTypeVector %7 2
+%9 = OpConstant %7 1
+%10 = OpConstantComposite %6 %9 %9
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %8 )" + param.op +
+                                R"( %10 %10 %10
+OpFunctionEnd
+)");
+}
+INSTANTIATE_TEST_SUITE_P(
+    BuilderTest,
+    Intrinsic_Builtin_ThreeParam_Float_Test,
+    testing::Values(IntrinsicData{"clamp", "NClamp"},
+                    IntrinsicData{"faceForward", "FaceForward"},
+                    IntrinsicData{"fma", "Fma"},
+                    IntrinsicData{"mix", "FMix"},
+
+                    IntrinsicData{"smoothStep", "SmoothStep"}));
+
+using Intrinsic_Builtin_SingleParam_Sint_Test =
+    testing::TestWithParam<IntrinsicData>;
+TEST_P(Intrinsic_Builtin_SingleParam_Sint_Test, Call_Scalar) {
+  auto param = GetParam();
+
+  ast::type::I32Type i32;
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%7 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%6 = OpTypeInt 32 1
+%8 = OpConstant %6 1
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %7 )" + param.op +
+                                R"( %8
+OpFunctionEnd
+)");
+}
+
+TEST_P(Intrinsic_Builtin_SingleParam_Sint_Test, Call_Vector) {
+  auto param = GetParam();
+
+  ast::type::I32Type i32;
+  ast::type::VectorType vec(&i32, 2);
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList vals;
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+
+  ast::ExpressionList params;
+  params.push_back(
+      std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%8 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%7 = OpTypeInt 32 1
+%6 = OpTypeVector %7 2
+%9 = OpConstant %7 1
+%10 = OpConstantComposite %6 %9 %9
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %8 )" + param.op +
+                                R"( %10
+OpFunctionEnd
+)");
+}
+INSTANTIATE_TEST_SUITE_P(BuilderTest,
+                         Intrinsic_Builtin_SingleParam_Sint_Test,
+                         testing::Values(IntrinsicData{"abs", "SAbs"}));
+
+using Intrinsic_Builtin_SingleParam_Uint_Test =
+    testing::TestWithParam<IntrinsicData>;
+TEST_P(Intrinsic_Builtin_SingleParam_Uint_Test, Call_Scalar) {
+  auto param = GetParam();
+
+  ast::type::U32Type u32;
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%7 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%6 = OpTypeInt 32 0
+%8 = OpConstant %6 1
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %7 )" + param.op +
+                                R"( %8
+OpFunctionEnd
+)");
+}
+
+TEST_P(Intrinsic_Builtin_SingleParam_Uint_Test, Call_Vector) {
+  auto param = GetParam();
+
+  ast::type::U32Type u32;
+  ast::type::VectorType vec(&u32, 2);
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList vals;
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+  vals.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+
+  ast::ExpressionList params;
+  params.push_back(
+      std::make_unique<ast::TypeConstructorExpression>(&vec, std::move(vals)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%8 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%7 = OpTypeInt 32 0
+%6 = OpTypeVector %7 2
+%9 = OpConstant %7 1
+%10 = OpConstantComposite %6 %9 %9
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %8 )" + param.op +
+                                R"( %10
+OpFunctionEnd
+)");
+}
+INSTANTIATE_TEST_SUITE_P(BuilderTest,
+                         Intrinsic_Builtin_SingleParam_Uint_Test,
+                         testing::Values(IntrinsicData{"abs", "SAbs"}));
+
+using Intrinsic_Builtin_DualParam_SInt_Test =
+    testing::TestWithParam<IntrinsicData>;
+TEST_P(Intrinsic_Builtin_DualParam_SInt_Test, Call_Scalar) {
+  auto param = GetParam();
+
+  ast::type::I32Type i32;
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%7 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%6 = OpTypeInt 32 1
+%8 = OpConstant %6 1
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %7 )" + param.op +
+                                R"( %8 %8
+OpFunctionEnd
+)");
+}
+
+TEST_P(Intrinsic_Builtin_DualParam_SInt_Test, Call_Vector) {
+  auto param = GetParam();
+
+  ast::type::I32Type i32;
+  ast::type::VectorType vec(&i32, 2);
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList vals_1;
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+
+  ast::ExpressionList vals_2;
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_1)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_2)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%8 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%7 = OpTypeInt 32 1
+%6 = OpTypeVector %7 2
+%9 = OpConstant %7 1
+%10 = OpConstantComposite %6 %9 %9
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %8 )" + param.op +
+                                R"( %10 %10
+OpFunctionEnd
+)");
+}
+INSTANTIATE_TEST_SUITE_P(BuilderTest,
+                         Intrinsic_Builtin_DualParam_SInt_Test,
+                         testing::Values(IntrinsicData{"max", "SMax"},
+                                         IntrinsicData{"min", "SMin"}));
+
+using Intrinsic_Builtin_DualParam_UInt_Test =
+    testing::TestWithParam<IntrinsicData>;
+TEST_P(Intrinsic_Builtin_DualParam_UInt_Test, Call_Scalar) {
+  auto param = GetParam();
+
+  ast::type::U32Type u32;
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%7 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%6 = OpTypeInt 32 0
+%8 = OpConstant %6 1
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %7 )" + param.op +
+                                R"( %8 %8
+OpFunctionEnd
+)");
+}
+
+TEST_P(Intrinsic_Builtin_DualParam_UInt_Test, Call_Vector) {
+  auto param = GetParam();
+
+  ast::type::U32Type u32;
+  ast::type::VectorType vec(&u32, 2);
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList vals_1;
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+
+  ast::ExpressionList vals_2;
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_1)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_2)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%8 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%7 = OpTypeInt 32 0
+%6 = OpTypeVector %7 2
+%9 = OpConstant %7 1
+%10 = OpConstantComposite %6 %9 %9
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %8 )" + param.op +
+                                R"( %10 %10
+OpFunctionEnd
+)");
+}
+INSTANTIATE_TEST_SUITE_P(BuilderTest,
+                         Intrinsic_Builtin_DualParam_UInt_Test,
+                         testing::Values(IntrinsicData{"max", "UMax"},
+                                         IntrinsicData{"min", "UMin"}));
+
+using Intrinsic_Builtin_ThreeParam_Sint_Test =
+    testing::TestWithParam<IntrinsicData>;
+TEST_P(Intrinsic_Builtin_ThreeParam_Sint_Test, Call_Scalar) {
+  auto param = GetParam();
+
+  ast::type::I32Type i32;
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%7 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%6 = OpTypeInt 32 1
+%8 = OpConstant %6 1
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %7 )" + param.op +
+                                R"( %8 %8 %8
+OpFunctionEnd
+)");
+}
+
+TEST_P(Intrinsic_Builtin_ThreeParam_Sint_Test, Call_Vector) {
+  auto param = GetParam();
+
+  ast::type::I32Type i32;
+  ast::type::VectorType vec(&i32, 2);
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList vals_1;
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+
+  ast::ExpressionList vals_2;
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+
+  ast::ExpressionList vals_3;
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::SintLiteral>(&i32, 1)));
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_1)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_2)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_3)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%8 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%7 = OpTypeInt 32 1
+%6 = OpTypeVector %7 2
+%9 = OpConstant %7 1
+%10 = OpConstantComposite %6 %9 %9
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %8 )" + param.op +
+                                R"( %10 %10 %10
+OpFunctionEnd
+)");
+}
+INSTANTIATE_TEST_SUITE_P(BuilderTest,
+                         Intrinsic_Builtin_ThreeParam_Sint_Test,
+                         testing::Values(IntrinsicData{"clamp", "SClamp"}));
+
+using Intrinsic_Builtin_ThreeParam_Uint_Test =
+    testing::TestWithParam<IntrinsicData>;
+TEST_P(Intrinsic_Builtin_ThreeParam_Uint_Test, Call_Scalar) {
+  auto param = GetParam();
+
+  ast::type::U32Type u32;
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+  params.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%7 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%6 = OpTypeInt 32 0
+%8 = OpConstant %6 1
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %7 )" + param.op +
+                                R"( %8 %8 %8
+OpFunctionEnd
+)");
+}
+
+TEST_P(Intrinsic_Builtin_ThreeParam_Uint_Test, Call_Vector) {
+  auto param = GetParam();
+
+  ast::type::U32Type u32;
+  ast::type::VectorType vec(&u32, 2);
+  ast::type::VoidType void_type;
+
+  ast::ExpressionList vals_1;
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+  vals_1.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+
+  ast::ExpressionList vals_2;
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+  vals_2.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+
+  ast::ExpressionList vals_3;
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+  vals_3.push_back(std::make_unique<ast::ScalarConstructorExpression>(
+      std::make_unique<ast::UintLiteral>(&u32, 1)));
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_1)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_2)));
+  params.push_back(std::make_unique<ast::TypeConstructorExpression>(
+      &vec, std::move(vals_3)));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>(param.name),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 5u) << b.error();
+  EXPECT_EQ(DumpBuilder(b), R"(%8 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%7 = OpTypeInt 32 0
+%6 = OpTypeVector %7 2
+%9 = OpConstant %7 1
+%10 = OpConstantComposite %6 %9 %9
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%5 = OpExtInst %6 %8 )" + param.op +
+                                R"( %10 %10 %10
+OpFunctionEnd
+)");
+}
+INSTANTIATE_TEST_SUITE_P(BuilderTest,
+                         Intrinsic_Builtin_ThreeParam_Uint_Test,
+                         testing::Values(IntrinsicData{"clamp", "UClamp"}));
+
+TEST_F(BuilderTest, Call_Determinant) {
+  ast::type::F32Type f32;
+  ast::type::VoidType void_type;
+  ast::type::MatrixType mat(&f32, 3, 3);
+
+  auto var =
+      std::make_unique<ast::Variable>("var", ast::StorageClass::kPrivate, &mat);
+
+  ast::ExpressionList params;
+  params.push_back(std::make_unique<ast::IdentifierExpression>("var"));
+
+  ast::CallExpression expr(
+      std::make_unique<ast::IdentifierExpression>("determinant"),
+      std::move(params));
+
+  Context ctx;
+  ast::Module mod;
+  TypeDeterminer td(&ctx, &mod);
+  td.RegisterVariableForTesting(var.get());
+
+  ASSERT_TRUE(td.DetermineResultType(&expr)) << td.error();
+
+  ast::Function func("a_func", {}, &void_type);
+
+  Builder b(&mod);
+  ASSERT_TRUE(b.GenerateFunction(&func)) << b.error();
+
+  ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
+  EXPECT_EQ(b.GenerateCallExpression(&expr), 11u) << b.error();
+
+  EXPECT_EQ(DumpBuilder(b), R"(%12 = OpExtInstImport "GLSL.std.450"
+OpName %3 "a_func"
+OpName %5 "var"
+%2 = OpTypeVoid
+%1 = OpTypeFunction %2
+%9 = OpTypeFloat 32
+%8 = OpTypeVector %9 3
+%7 = OpTypeMatrix %8 3
+%6 = OpTypePointer Private %7
+%10 = OpConstantNull %7
+%5 = OpVariable %6 Private %10
+%3 = OpFunction %2 None %1
+%4 = OpLabel
+%13 = OpLoad %7 %5
+%11 = OpExtInst %9 %12 Determinant %13
+OpFunctionEnd
+)");
+}
+
 }  // namespace
 }  // namespace spirv
 }  // namespace writer
diff --git a/src/writer/spirv/builder_test.cc b/src/writer/spirv/builder_test.cc
index 6c80d8f..1e22d5f 100644
--- a/src/writer/spirv/builder_test.cc
+++ b/src/writer/spirv/builder_test.cc
@@ -19,7 +19,6 @@
 #include "gtest/gtest.h"
 #include "spirv/unified1/spirv.h"
 #include "spirv/unified1/spirv.hpp11"
-#include "src/ast/import.h"
 #include "src/ast/module.h"
 #include "src/writer/spirv/spv_dump.h"
 
@@ -30,24 +29,7 @@
 
 using BuilderTest = testing::Test;
 
-TEST_F(BuilderTest, InsertsPreambleWithImport) {
-  ast::Module m;
-  m.AddImport(std::make_unique<ast::Import>("GLSL.std.450", "glsl"));
-
-  Builder b(&m);
-  ASSERT_TRUE(b.Build());
-  ASSERT_EQ(b.capabilities().size(), 2u);
-  ASSERT_EQ(b.preamble().size(), 3u);
-
-  EXPECT_EQ(DumpBuilder(b), R"(OpCapability Shader
-OpCapability VulkanMemoryModel
-OpExtension "SPV_KHR_vulkan_memory_model"
-%1 = OpExtInstImport "GLSL.std.450"
-OpMemoryModel Logical Vulkan
-)");
-}
-
-TEST_F(BuilderTest, InsertsPreambleWithoutImport) {
+TEST_F(BuilderTest, InsertsPreamble) {
   ast::Module m;
   Builder b(&m);
   ASSERT_TRUE(b.Build());
diff --git a/src/writer/wgsl/generator_impl.cc b/src/writer/wgsl/generator_impl.cc
index da4aed2..6f0073c 100644
--- a/src/writer/wgsl/generator_impl.cc
+++ b/src/writer/wgsl/generator_impl.cc
@@ -75,15 +75,6 @@
 GeneratorImpl::~GeneratorImpl() = default;
 
 bool GeneratorImpl::Generate(const ast::Module& module) {
-  for (const auto& import : module.imports()) {
-    if (!EmitImport(import.get())) {
-      return false;
-    }
-  }
-  if (!module.imports().empty()) {
-    out_ << std::endl;
-  }
-
   for (auto* const alias : module.alias_types()) {
     if (!EmitAliasType(alias)) {
       return false;
@@ -114,16 +105,6 @@
 bool GeneratorImpl::GenerateEntryPoint(const ast::Module& module,
                                        ast::PipelineStage stage,
                                        const std::string& name) {
-  // TODO(dsinclair): We're always emitting imports even if they aren't needed.
-  for (const auto& import : module.imports()) {
-    if (!EmitImport(import.get())) {
-      return false;
-    }
-  }
-  if (!module.imports().empty()) {
-    out_ << std::endl;
-  }
-
   auto* func = module.FindFunctionByNameAndStage(name, stage);
   if (func == nullptr) {
     error_ = "Unable to find requested entry point: " + name;
@@ -365,20 +346,10 @@
 
 bool GeneratorImpl::EmitIdentifier(ast::IdentifierExpression* expr) {
   auto* ident = expr->AsIdentifier();
-  if (ident->has_path()) {
-    out_ << ident->path() << "::";
-  }
   out_ << ident->name();
   return true;
 }
 
-bool GeneratorImpl::EmitImport(const ast::Import* import) {
-  make_indent();
-  out_ << R"(import ")" << import->path() << R"(" as )" << import->name() << ";"
-       << std::endl;
-  return true;
-}
-
 bool GeneratorImpl::EmitFunction(ast::Function* func) {
   for (auto& deco : func->decorations()) {
     make_indent();
diff --git a/src/writer/wgsl/generator_impl.h b/src/writer/wgsl/generator_impl.h
index 1ae3853..43947a0 100644
--- a/src/writer/wgsl/generator_impl.h
+++ b/src/writer/wgsl/generator_impl.h
@@ -21,7 +21,6 @@
 #include "src/ast/array_accessor_expression.h"
 #include "src/ast/constructor_expression.h"
 #include "src/ast/identifier_expression.h"
-#include "src/ast/import.h"
 #include "src/ast/module.h"
 #include "src/ast/scalar_constructor_expression.h"
 #include "src/ast/type/alias_type.h"
@@ -135,10 +134,6 @@
   /// @param stmt the statement to emit
   /// @returns true if the statement was successfully emitted
   bool EmitIf(ast::IfStatement* stmt);
-  /// Handles generating an import command
-  /// @param import the import to generate
-  /// @returns true if the import was emitted
-  bool EmitImport(const ast::Import* import);
   /// Handles generating constructor expressions
   /// @param expr the constructor expression
   /// @returns true if the expression was emitted
diff --git a/src/writer/wgsl/generator_impl_identifier_test.cc b/src/writer/wgsl/generator_impl_identifier_test.cc
index eb5e9c0..503579a 100644
--- a/src/writer/wgsl/generator_impl_identifier_test.cc
+++ b/src/writer/wgsl/generator_impl_identifier_test.cc
@@ -22,14 +22,6 @@
 
 using WgslGeneratorImplTest = testing::Test;
 
-TEST_F(WgslGeneratorImplTest, EmitExpression_Identifier) {
-  ast::IdentifierExpression i(std::vector<std::string>{"std", "glsl"});
-
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitExpression(&i)) << g.error();
-  EXPECT_EQ(g.result(), "std::glsl");
-}
-
 TEST_F(WgslGeneratorImplTest, EmitIdentifierExpression_Single) {
   ast::IdentifierExpression i("glsl");
 
@@ -38,14 +30,6 @@
   EXPECT_EQ(g.result(), "glsl");
 }
 
-TEST_F(WgslGeneratorImplTest, EmitIdentifierExpression_MultipleNames) {
-  ast::IdentifierExpression i({"std", "glsl", "init"});
-
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitExpression(&i)) << g.error();
-  EXPECT_EQ(g.result(), "std::glsl::init");
-}
-
 }  // namespace
 }  // namespace wgsl
 }  // namespace writer
diff --git a/src/writer/wgsl/generator_impl_import_test.cc b/src/writer/wgsl/generator_impl_import_test.cc
deleted file mode 100644
index 24d1980..0000000
--- a/src/writer/wgsl/generator_impl_import_test.cc
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "gtest/gtest.h"
-#include "src/writer/wgsl/generator_impl.h"
-
-namespace tint {
-namespace writer {
-namespace wgsl {
-namespace {
-
-using WgslGeneratorImplTest = testing::Test;
-
-TEST_F(WgslGeneratorImplTest, EmitImport) {
-  ast::Import import("GLSL.std.450", "std::glsl");
-
-  GeneratorImpl g;
-  ASSERT_TRUE(g.EmitImport(&import)) << g.error();
-  EXPECT_EQ(g.result(), R"(import "GLSL.std.450" as std::glsl;
-)");
-}
-
-}  // namespace
-}  // namespace wgsl
-}  // namespace writer
-}  // namespace tint
diff --git a/src/writer/wgsl/generator_impl_test.cc b/src/writer/wgsl/generator_impl_test.cc
index b4420d6..675111d 100644
--- a/src/writer/wgsl/generator_impl_test.cc
+++ b/src/writer/wgsl/generator_impl_test.cc
@@ -17,6 +17,9 @@
 #include <memory>
 
 #include "gtest/gtest.h"
+#include "src/ast/function.h"
+#include "src/ast/module.h"
+#include "src/ast/type/void_type.h"
 
 namespace tint {
 namespace writer {
@@ -26,13 +29,17 @@
 using WgslGeneratorImplTest = testing::Test;
 
 TEST_F(WgslGeneratorImplTest, Generate) {
+  ast::type::VoidType void_type;
+
   ast::Module m;
-  m.AddImport(std::make_unique<ast::Import>("GLSL.std.430", "a"));
+  m.AddFunction(std::make_unique<ast::Function>("my_func", ast::VariableList{},
+                                                &void_type));
 
   GeneratorImpl g;
 
   ASSERT_TRUE(g.Generate(m)) << g.error();
-  EXPECT_EQ(g.result(), R"(import "GLSL.std.430" as a;
+  EXPECT_EQ(g.result(), R"(fn my_func() -> void {
+}
 
 )");
 }