diff --git a/source/link/linker.cpp b/source/link/linker.cpp
index f28b759..d99a1e8 100644
--- a/source/link/linker.cpp
+++ b/source/link/linker.cpp
@@ -33,6 +33,7 @@
 #include "source/opt/ir_loader.h"
 #include "source/opt/pass_manager.h"
 #include "source/opt/remove_duplicates_pass.h"
+#include "source/opt/type_manager.h"
 #include "source/spirv_target_env.h"
 #include "source/util/make_unique.h"
 #include "spirv-tools/libspirv.hpp"
@@ -40,14 +41,15 @@
 namespace spvtools {
 namespace {
 
-using opt::IRContext;
 using opt::Instruction;
+using opt::IRContext;
 using opt::Module;
-using opt::Operand;
 using opt::PassManager;
 using opt::RemoveDuplicatesPass;
 using opt::analysis::DecorationManager;
 using opt::analysis::DefUseManager;
+using opt::analysis::Type;
+using opt::analysis::TypeManager;
 
 // Stores various information about an imported or exported symbol.
 struct LinkageSymbolInfo {
@@ -472,14 +474,15 @@
                                             opt::IRContext* context) {
   spv_position_t position = {};
 
-  // Ensure th import and export types are the same.
-  const DefUseManager& def_use_manager = *context->get_def_use_mgr();
+  // Ensure the import and export types are the same.
   const DecorationManager& decoration_manager = *context->get_decoration_mgr();
+  const TypeManager& type_manager = *context->get_type_mgr();
   for (const auto& linking_entry : linkings_to_do) {
-    if (!RemoveDuplicatesPass::AreTypesEqual(
-            *def_use_manager.GetDef(linking_entry.imported_symbol.type_id),
-            *def_use_manager.GetDef(linking_entry.exported_symbol.type_id),
-            context))
+    Type* imported_symbol_type =
+        type_manager.GetType(linking_entry.imported_symbol.type_id);
+    Type* exported_symbol_type =
+        type_manager.GetType(linking_entry.exported_symbol.type_id);
+    if (!(*imported_symbol_type == *exported_symbol_type))
       return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY)
              << "Type mismatch on symbol \""
              << linking_entry.imported_symbol.name
diff --git a/source/opt/remove_duplicates_pass.cpp b/source/opt/remove_duplicates_pass.cpp
index a37e9df..0e65cc8 100644
--- a/source/opt/remove_duplicates_pass.cpp
+++ b/source/opt/remove_duplicates_pass.cpp
@@ -96,35 +96,67 @@
     return modified;
   }
 
+  analysis::TypeManager type_manager(context()->consumer(), context());
+
   std::vector<Instruction*> visited_types;
+  std::vector<analysis::ForwardPointer> visited_forward_pointers;
   std::vector<Instruction*> to_delete;
   for (auto* i = &*context()->types_values_begin(); i; i = i->NextNode()) {
+    const bool is_i_forward_pointer = i->opcode() == SpvOpTypeForwardPointer;
+
     // We only care about types.
-    if (!spvOpcodeGeneratesType((i->opcode())) &&
-        i->opcode() != SpvOpTypeForwardPointer) {
+    if (!spvOpcodeGeneratesType(i->opcode()) && !is_i_forward_pointer) {
       continue;
     }
 
-    // Is the current type equal to one of the types we have aready visited?
-    SpvId id_to_keep = 0u;
-    // TODO(dneto0): Use a trie to avoid quadratic behaviour? Extract the
-    // ResultIdTrie from unify_const_pass.cpp for this.
-    for (auto j : visited_types) {
-      if (AreTypesEqual(*i, *j, context())) {
-        id_to_keep = j->result_id();
-        break;
+    if (!is_i_forward_pointer) {
+      // Is the current type equal to one of the types we have already visited?
+      SpvId id_to_keep = 0u;
+      analysis::Type* i_type = type_manager.GetType(i->result_id());
+      assert(i_type);
+      // TODO(dneto0): Use a trie to avoid quadratic behaviour? Extract the
+      // ResultIdTrie from unify_const_pass.cpp for this.
+      for (auto j : visited_types) {
+        analysis::Type* j_type = type_manager.GetType(j->result_id());
+        assert(j_type);
+        if (*i_type == *j_type) {
+          id_to_keep = j->result_id();
+          break;
+        }
       }
-    }
 
-    if (id_to_keep == 0u) {
-      // This is a never seen before type, keep it around.
-      visited_types.emplace_back(i);
+      if (id_to_keep == 0u) {
+        // This is a never seen before type, keep it around.
+        visited_types.emplace_back(i);
+      } else {
+        // The same type has already been seen before, remove this one.
+        context()->KillNamesAndDecorates(i->result_id());
+        context()->ReplaceAllUsesWith(i->result_id(), id_to_keep);
+        modified = true;
+        to_delete.emplace_back(i);
+      }
     } else {
-      // The same type has already been seen before, remove this one.
-      context()->KillNamesAndDecorates(i->result_id());
-      context()->ReplaceAllUsesWith(i->result_id(), id_to_keep);
-      modified = true;
-      to_delete.emplace_back(i);
+      analysis::ForwardPointer i_type(
+          i->GetSingleWordInOperand(0u),
+          (SpvStorageClass)i->GetSingleWordInOperand(1u));
+      i_type.SetTargetPointer(
+          type_manager.GetType(i_type.target_id())->AsPointer());
+
+      // TODO(dneto0): Use a trie to avoid quadratic behaviour? Extract the
+      // ResultIdTrie from unify_const_pass.cpp for this.
+      const bool found_a_match =
+          std::find(std::begin(visited_forward_pointers),
+                    std::end(visited_forward_pointers),
+                    i_type) != std::end(visited_forward_pointers);
+
+      if (!found_a_match) {
+        // This is a never seen before type, keep it around.
+        visited_forward_pointers.emplace_back(i_type);
+      } else {
+        // The same type has already been seen before, remove this one.
+        modified = true;
+        to_delete.emplace_back(i);
+      }
     }
   }
 
@@ -151,8 +183,8 @@
 
   analysis::DecorationManager decoration_manager(context()->module());
   for (auto* i = &*context()->annotation_begin(); i;) {
-    // Is the current decoration equal to one of the decorations we have aready
-    // visited?
+    // Is the current decoration equal to one of the decorations we have
+    // already visited?
     bool already_visited = false;
     // TODO(dneto0): Use a trie to avoid quadratic behaviour? Extract the
     // ResultIdTrie from unify_const_pass.cpp for this.
@@ -177,20 +209,5 @@
   return modified;
 }
 
-bool RemoveDuplicatesPass::AreTypesEqual(const Instruction& inst1,
-                                         const Instruction& inst2,
-                                         IRContext* context) {
-  if (inst1.opcode() != inst2.opcode()) return false;
-  if (!IsTypeInst(inst1.opcode())) return false;
-
-  const analysis::Type* type1 =
-      context->get_type_mgr()->GetType(inst1.result_id());
-  const analysis::Type* type2 =
-      context->get_type_mgr()->GetType(inst2.result_id());
-  if (type1 && type2 && *type1 == *type2) return true;
-
-  return false;
-}
-
 }  // namespace opt
 }  // namespace spvtools
diff --git a/source/opt/remove_duplicates_pass.h b/source/opt/remove_duplicates_pass.h
index 8554a98..038caa8 100644
--- a/source/opt/remove_duplicates_pass.h
+++ b/source/opt/remove_duplicates_pass.h
@@ -36,12 +36,6 @@
   const char* name() const override { return "remove-duplicates"; }
   Status Process() override;
 
-  // TODO(pierremoreau): Move this function somewhere else (e.g. pass.h or
-  // within the type manager)
-  // Returns whether two types are equal, and have the same decorations.
-  static bool AreTypesEqual(const Instruction& inst1, const Instruction& inst2,
-                            IRContext* context);
-
  private:
   // Remove duplicate capabilities from the module
   //
diff --git a/source/opt/type_manager.cpp b/source/opt/type_manager.cpp
index 001883c..113dc80 100644
--- a/source/opt/type_manager.cpp
+++ b/source/opt/type_manager.cpp
@@ -66,7 +66,13 @@
 }
 
 void TypeManager::AnalyzeTypes(const Module& module) {
-  // First pass through the types.  Any types that reference a forward pointer
+  // First pass through the constants, as some will be needed when traversing
+  // the types in the next pass.
+  for (const auto* inst : module.GetConstants()) {
+    id_to_constant_inst_[inst->result_id()] = inst;
+  }
+
+  // Then pass through the types.  Any types that reference a forward pointer
   // (directly or indirectly) are incomplete, and are added to incomplete types.
   for (const auto* inst : module.GetTypes()) {
     RecordIfTypeDefinition(*inst);
@@ -154,7 +160,7 @@
 
 #ifndef NDEBUG
   // Check if the type pool contains two types that are the same.  This
-  // is an indication that the hashing and comparision are wrong.  It
+  // is an indication that the hashing and comparison are wrong.  It
   // will cause a problem if the type pool gets resized and everything
   // is rehashed.
   for (auto& i : type_pool_) {
@@ -505,8 +511,15 @@
     case Type::kArray: {
       const Array* array_ty = type.AsArray();
       const Type* ele_ty = array_ty->element_type();
-      rebuilt_ty =
-          MakeUnique<Array>(RebuildType(*ele_ty), array_ty->LengthId());
+      if (array_ty->length_spec_id() != 0u)
+        rebuilt_ty =
+            MakeUnique<Array>(RebuildType(*ele_ty), array_ty->LengthId(),
+                              array_ty->length_spec_id());
+      else
+        rebuilt_ty =
+            MakeUnique<Array>(RebuildType(*ele_ty), array_ty->LengthId(),
+                              array_ty->length_constant_type(),
+                              array_ty->length_constant_words());
       break;
     }
     case Type::kRuntimeArray: {
@@ -636,15 +649,39 @@
     case SpvOpTypeSampledImage:
       type = new SampledImage(GetType(inst.GetSingleWordInOperand(0)));
       break;
-    case SpvOpTypeArray:
-      type = new Array(GetType(inst.GetSingleWordInOperand(0)),
-                       inst.GetSingleWordInOperand(1));
+    case SpvOpTypeArray: {
+      const uint32_t length_id = inst.GetSingleWordInOperand(1);
+      const Instruction* length_constant_inst = id_to_constant_inst_[length_id];
+      assert(length_constant_inst);
+
+      // If it is a specialised constants, retrieve its SpecId.
+      uint32_t spec_id = 0u;
+      Type* length_type = nullptr;
+      Operand::OperandData length_words;
+      if (spvOpcodeIsSpecConstant(length_constant_inst->opcode())) {
+        context()->get_decoration_mgr()->ForEachDecoration(
+            length_id, SpvDecorationSpecId,
+            [&spec_id](const Instruction& decoration) {
+              assert(decoration.opcode() == SpvOpDecorate);
+              spec_id = decoration.GetSingleWordOperand(2u);
+            });
+      } else {
+        length_type = GetType(length_constant_inst->type_id());
+        length_words = length_constant_inst->GetOperand(2u).words;
+      }
+
+      if (spec_id != 0u)
+        type = new Array(GetType(inst.GetSingleWordInOperand(0)), length_id,
+                         spec_id);
+      else
+        type = new Array(GetType(inst.GetSingleWordInOperand(0)), length_id,
+                         length_type, length_words);
       if (id_to_incomplete_type_.count(inst.GetSingleWordInOperand(0))) {
         incomplete_types_.emplace_back(inst.result_id(), type);
         id_to_incomplete_type_[inst.result_id()] = type;
         return type;
       }
-      break;
+    } break;
     case SpvOpTypeRuntimeArray:
       type = new RuntimeArray(GetType(inst.GetSingleWordInOperand(0)));
       if (id_to_incomplete_type_.count(inst.GetSingleWordInOperand(0))) {
diff --git a/source/opt/type_manager.h b/source/opt/type_manager.h
index c44969e..ecc7858 100644
--- a/source/opt/type_manager.h
+++ b/source/opt/type_manager.h
@@ -209,6 +209,8 @@
 
   IdToTypeMap id_to_incomplete_type_;  // Maps ids to their type representations
                                        // for incomplete types.
+
+  std::unordered_map<uint32_t, const Instruction*> id_to_constant_inst_;
 };
 
 }  // namespace analysis
diff --git a/source/opt/types.cpp b/source/opt/types.cpp
index cfafc7d..af747cf 100644
--- a/source/opt/types.cpp
+++ b/source/opt/types.cpp
@@ -383,17 +383,46 @@
   image_type_->GetHashWords(words, seen);
 }
 
-Array::Array(Type* type, uint32_t length_id)
-    : Type(kArray), element_type_(type), length_id_(length_id) {
+Array::Array(Type* type, uint32_t length_id, uint32_t spec_id)
+    : Type(kArray),
+      element_type_(type),
+      length_id_(length_id),
+      length_spec_id_(spec_id),
+      length_constant_type_(nullptr),
+      length_constant_words_() {
   assert(!type->AsVoid());
+  assert(spec_id != 0u);
+}
+
+Array::Array(Type* type, uint32_t length_id, const Type* constant_type,
+             Operand::OperandData constant_words)
+    : Type(kArray),
+      element_type_(type),
+      length_id_(length_id),
+      length_spec_id_(0u),
+      length_constant_type_(constant_type),
+      length_constant_words_(constant_words) {
+  assert(!type->AsVoid());
+  assert(constant_type && constant_type->AsInteger());
 }
 
 bool Array::IsSameImpl(const Type* that, IsSameCache* seen) const {
   const Array* at = that->AsArray();
   if (!at) return false;
-  return length_id_ == at->length_id_ &&
-         element_type_->IsSameImpl(at->element_type_, seen) &&
-         HasSameDecorations(that);
+  bool is_same = element_type_->IsSameImpl(at->element_type_, seen) &&
+                 HasSameDecorations(that);
+  // If it is a specialized constant
+  if (length_spec_id_ != 0u) {
+    // ensure they have the same SpecId
+    is_same = is_same && length_spec_id_ == at->length_spec_id_;
+  } else {
+    // else, ensure they have the same length literal number.
+    is_same =
+        is_same &&
+        length_constant_type_->IsSameImpl(at->length_constant_type_, seen) &&
+        length_constant_words_ == at->length_constant_words_;
+  }
+  return is_same;
 }
 
 std::string Array::str() const {
@@ -405,7 +434,13 @@
 void Array::GetExtraHashWords(std::vector<uint32_t>* words,
                               std::unordered_set<const Type*>* seen) const {
   element_type_->GetHashWords(words, seen);
-  words->push_back(length_id_);
+  if (length_spec_id_ != 0u) {
+    words->push_back(length_spec_id_);
+  } else {
+    length_constant_type_->GetHashWords(words, seen);
+    words->insert(words->end(), length_constant_words_.begin(),
+                  length_constant_words_.end());
+  }
 }
 
 void Array::ReplaceElementType(const Type* type) { element_type_ = type; }
@@ -609,7 +644,8 @@
 bool ForwardPointer::IsSameImpl(const Type* that, IsSameCache*) const {
   const ForwardPointer* fpt = that->AsForwardPointer();
   if (!fpt) return false;
-  return target_id_ == fpt->target_id_ &&
+  return (pointer_ && fpt->pointer_ ? *pointer_ == *fpt->pointer_
+                                    : target_id_ == fpt->target_id_) &&
          storage_class_ == fpt->storage_class_ && HasSameDecorations(that);
 }
 
diff --git a/source/opt/types.h b/source/opt/types.h
index fe0f39a..381cab6 100644
--- a/source/opt/types.h
+++ b/source/opt/types.h
@@ -27,6 +27,7 @@
 #include <vector>
 
 #include "source/latest_version_spirv_header.h"
+#include "source/opt/instruction.h"
 #include "spirv-tools/libspirv.h"
 
 namespace spvtools {
@@ -356,12 +357,19 @@
 
 class Array : public Type {
  public:
-  Array(Type* element_type, uint32_t length_id);
+  Array(Type* element_type, uint32_t length_id, uint32_t spec_id);
+  Array(Type* element_type, uint32_t length_id, const Type* constant_type,
+        Operand::OperandData constant_words);
   Array(const Array&) = default;
 
   std::string str() const override;
   const Type* element_type() const { return element_type_; }
   uint32_t LengthId() const { return length_id_; }
+  uint32_t length_spec_id() const { return length_spec_id_; }
+  const Type* length_constant_type() const { return length_constant_type_; }
+  Operand::OperandData length_constant_words() const {
+    return length_constant_words_;
+  }
 
   Array* AsArray() override { return this; }
   const Array* AsArray() const override { return this; }
@@ -376,6 +384,9 @@
 
   const Type* element_type_;
   uint32_t length_id_;
+  uint32_t length_spec_id_;
+  const Type* length_constant_type_;
+  Operand::OperandData length_constant_words_;
 };
 
 class RuntimeArray : public Type {
diff --git a/test/link/type_match_test.cpp b/test/link/type_match_test.cpp
index 291d13d..c12ffb3 100644
--- a/test/link/type_match_test.cpp
+++ b/test/link/type_match_test.cpp
@@ -21,34 +21,39 @@
 using TypeMatch = spvtest::LinkerTest;
 
 // Basic types
-#define PartInt(N) N " = OpTypeInt 32 0"
-#define PartFloat(N) N " = OpTypeFloat 32"
-#define PartOpaque(N) N " = OpTypeOpaque \"bar\""
-#define PartSampler(N) N " = OpTypeSampler"
-#define PartEvent(N) N " = OpTypeEvent"
-#define PartDeviceEvent(N) N " = OpTypeDeviceEvent"
-#define PartReserveId(N) N " = OpTypeReserveId"
-#define PartQueue(N) N " = OpTypeQueue"
-#define PartPipe(N) N " = OpTypePipe ReadWrite"
-#define PartPipeStorage(N) N " = OpTypePipeStorage"
-#define PartNamedBarrier(N) N " = OpTypeNamedBarrier"
+#define PartInt(D, N) D(N) " = OpTypeInt 32 0"
+#define PartFloat(D, N) D(N) " = OpTypeFloat 32"
+#define PartOpaque(D, N) D(N) " = OpTypeOpaque \"bar\""
+#define PartSampler(D, N) D(N) " = OpTypeSampler"
+#define PartEvent(D, N) D(N) " = OpTypeEvent"
+#define PartDeviceEvent(D, N) D(N) " = OpTypeDeviceEvent"
+#define PartReserveId(D, N) D(N) " = OpTypeReserveId"
+#define PartQueue(D, N) D(N) " = OpTypeQueue"
+#define PartPipe(D, N) D(N) " = OpTypePipe ReadWrite"
+#define PartPipeStorage(D, N) D(N) " = OpTypePipeStorage"
+#define PartNamedBarrier(D, N) D(N) " = OpTypeNamedBarrier"
 
 // Compound types
-#define PartVector(N, T) N " = OpTypeVector " T " 3"
-#define PartMatrix(N, T) N " = OpTypeMatrix " T " 4"
-#define PartImage(N, T) N " = OpTypeImage " T " 2D 0 0 0 0 Rgba32f"
-#define PartSampledImage(N, T) N " = OpTypeSampledImage " T
-#define PartArray(N, T) N " = OpTypeArray " T " %const"
-#define PartRuntimeArray(N, T) N " = OpTypeRuntimeArray " T
-#define PartStruct(N, T) N " = OpTypeStruct " T " " T
-#define PartPointer(N, T) N " = OpTypePointer Workgroup " T
-#define PartFunction(N, T) N " = OpTypeFunction " T " " T
+#define PartVector(DR, DA, N, T) DR(N) " = OpTypeVector " DA(T) " 3"
+#define PartMatrix(DR, DA, N, T) DR(N) " = OpTypeMatrix " DA(T) " 4"
+#define PartImage(DR, DA, N, T) \
+  DR(N) " = OpTypeImage " DA(T) " 2D 0 0 0 0 Rgba32f"
+#define PartSampledImage(DR, DA, N, T) DR(N) " = OpTypeSampledImage " DA(T)
+#define PartArray(DR, DA, N, T) DR(N) " = OpTypeArray " DA(T) " " DA(const)
+#define PartRuntimeArray(DR, DA, N, T) DR(N) " = OpTypeRuntimeArray " DA(T)
+#define PartStruct(DR, DA, N, T) DR(N) " = OpTypeStruct " DA(T) " " DA(T)
+#define PartPointer(DR, DA, N, T) DR(N) " = OpTypePointer Workgroup " DA(T)
+#define PartFunction(DR, DA, N, T) DR(N) " = OpTypeFunction " DA(T) " " DA(T)
+
+#define CheckDecoRes(S) "[[" #S ":%\\w+]]"
+#define CheckDecoArg(S) "[[" #S "]]"
+#define InstDeco(S) "%" #S
 
 #define MatchPart1(F, N) \
-  "; CHECK: " Part##F("[[" #N ":%\\w+]]") "\n" Part##F("%" #N) "\n"
-#define MatchPart2(F, N, T)                                                 \
-  "; CHECK: " Part##F("[[" #N ":%\\w+]]", "[[" #T ":%\\w+]]") "\n" Part##F( \
-      "%" #N, "%" #T) "\n"
+  "; CHECK: " Part##F(CheckDecoRes, N) "\n" Part##F(InstDeco, N) "\n"
+#define MatchPart2(F, N, T)                                           \
+  "; CHECK: " Part##F(CheckDecoRes, CheckDecoArg, N, T) "\n" Part##F( \
+      InstDeco, InstDeco, N, T) "\n"
 
 #define MatchF(N, CODE)                                         \
   TEST_F(TypeMatch, N) {                                        \
@@ -98,47 +103,42 @@
 Match2(Image, Float);
 
 // Unrestricted compound types
-// The following skip Array as it causes issues
 #define MatchCompounds1(A) \
   Match2(RuntimeArray, A); \
   Match2(Struct, A);       \
   Match2(Pointer, A);      \
   Match2(Function, A);     \
-// Match2(Array, A);  // Disabled as it fails currently
+  Match2(Array, A);
 #define MatchCompounds2(A, B) \
   Match3(RuntimeArray, A, B); \
   Match3(Struct, A, B);       \
   Match3(Pointer, A, B);      \
   Match3(Function, A, B);     \
-  // Match3(Array, A, B);  // Disabled as it fails currently
+  Match3(Array, A, B);
 
 MatchCompounds1(Float);
-// MatchCompounds2(Array, Float);
+MatchCompounds2(Array, Float);
 MatchCompounds2(RuntimeArray, Float);
 MatchCompounds2(Struct, Float);
 MatchCompounds2(Pointer, Float);
 MatchCompounds2(Function, Float);
 
 // ForwardPointer tests, which don't fit into the previous mold
-#define MatchFpF(N, CODE)                                                    \
-  MatchF(N,                                                                  \
-         "; CHECK: [[type:%\\w+]] = OpTypeForwardPointer [[pointer:%\\w+]] " \
-         "Workgroup\n"                                                       \
-         "%type = OpTypeForwardPointer %pointer Workgroup\n" CODE            \
-         "; CHECK: [[pointer]] = OpTypePointer Workgroup [[realtype]]\n"     \
-         "%pointer = OpTypePointer Workgroup %realtype\n")
+#define MatchFpF(N, CODE)                                             \
+  MatchF(N,                                                           \
+         "; CHECK: OpTypeForwardPointer [[type:%\\w+]] Workgroup\n"   \
+         "OpTypeForwardPointer %type Workgroup\n" CODE                \
+         "; CHECK: [[type]] = OpTypePointer Workgroup [[realtype]]\n" \
+         "%type = OpTypePointer Workgroup %realtype\n")
 #define MatchFp1(T) MatchFpF(ForwardPointerOf##T, MatchPart1(T, realtype))
 #define MatchFp2(T, A) \
   MatchFpF(ForwardPointerOf##T, MatchPart1(A, a) MatchPart2(T, realtype, a))
 
-// Disabled currently, causes assertion failures
-/*
 MatchFp1(Float);
 MatchFp2(Array, Float);
 MatchFp2(RuntimeArray, Float);
 MatchFp2(Struct, Float);
 MatchFp2(Function, Float);
-// */
 
 }  // namespace
 }  // namespace spvtools
diff --git a/test/opt/type_manager_test.cpp b/test/opt/type_manager_test.cpp
index 1072c36..c5ff9e6 100644
--- a/test/opt/type_manager_test.cpp
+++ b/test/opt/type_manager_test.cpp
@@ -117,10 +117,10 @@
   types.emplace_back(new SampledImage(image2));
 
   // Array
-  types.emplace_back(new Array(f32, 100));
-  types.emplace_back(new Array(f32, 42));
+  types.emplace_back(new Array(f32, 100, 1u));
+  types.emplace_back(new Array(f32, 42, 2u));
   auto* a42f32 = types.back().get();
-  types.emplace_back(new Array(u64, 24));
+  types.emplace_back(new Array(u64, 24, s32, {42}));
 
   // RuntimeArray
   types.emplace_back(new RuntimeArray(v3f32));
diff --git a/test/opt/types_test.cpp b/test/opt/types_test.cpp
index 7426ed7..2c0d8db 100644
--- a/test/opt/types_test.cpp
+++ b/test/opt/types_test.cpp
@@ -72,7 +72,7 @@
                                    SpvAccessQualifierWriteOnly);
 TestMultipleInstancesOfTheSameType(Sampler);
 TestMultipleInstancesOfTheSameType(SampledImage, image_t_.get());
-TestMultipleInstancesOfTheSameType(Array, u32_t_.get(), 10);
+TestMultipleInstancesOfTheSameType(Array, u32_t_.get(), 10, 3);
 TestMultipleInstancesOfTheSameType(RuntimeArray, u32_t_.get());
 TestMultipleInstancesOfTheSameType(Struct, std::vector<const Type*>{
                                                u32_t_.get(), f64_t_.get()});
@@ -151,10 +151,10 @@
   types.emplace_back(new SampledImage(image2));
 
   // Array
-  types.emplace_back(new Array(f32, 100));
-  types.emplace_back(new Array(f32, 42));
+  types.emplace_back(new Array(f32, 100, 1u));
+  types.emplace_back(new Array(f32, 42, 2u));
   auto* a42f32 = types.back().get();
-  types.emplace_back(new Array(u64, 24));
+  types.emplace_back(new Array(u64, 24, s32, {42}));
 
   // RuntimeArray
   types.emplace_back(new RuntimeArray(v3f32));