Allow PtrType in vector expressions.

Author: m-kurtenacker

src/check.cpp

@@ -83,7 +83,7 @@ const Type* TypeChecker::invalid_cast(const Loc& loc, const Type* type, const Ty
 
 const Type* TypeChecker::invalid_simd(const Loc& loc, const Type* elem_type) {
     if (should_report_error(elem_type))
-        error(loc, "expected primitive type for simd type component, but got '{}'", *elem_type);
+        error(loc, "expected primitive or pointer type for simd type component, but got '{}'", *elem_type);
     return type_table.type_error();
 }
 
@@ -489,7 +489,7 @@ const Type* TypeChecker::infer_array(
     if (elem_count == 0)
         return cannot_infer(loc, msg);
     auto elem_type = infer_elems();
-    if (is_simd && !elem_type->template isa<PrimType>())
+    if (is_simd && !(elem_type->template isa<PrimType>() || elem_type->template isa<PtrType>()))
         return invalid_simd(loc, elem_type);
     return type_table.sized_array_type(elem_type, elem_count, is_simd);
 }
@@ -509,7 +509,7 @@ const Type* TypeChecker::check_array(
     if (is_simd_type(array_type) != is_simd)
         return incompatible_type(loc, (is_simd ? "simd " : "non-simd ") + std::string(msg), expected);
     auto elem_type = array_type->elem;
-    if (is_simd && !elem_type->isa<PrimType>())
+    if (is_simd && !(elem_type->template isa<PrimType>() || elem_type->template isa<PtrType>()))
         return invalid_simd(loc, elem_type);
     check_elems(elem_type);
     if (auto sized_array_type = array_type->isa<artic::SizedArrayType>();
@@ -847,7 +847,7 @@ const artic::Type* TupleType::infer(TypeChecker& checker) {
 
 const artic::Type* SizedArrayType::infer(TypeChecker& checker) {
     auto elem_type = checker.infer(*elem);
-    if (is_simd && !elem_type->isa<artic::PrimType>())
+    if (is_simd && !(elem_type->template isa<artic::PrimType>() || elem_type->template isa<artic::PtrType>()))
         return checker.invalid_simd(loc, elem_type);
 
     if (std::holds_alternative<ast::Path>(size)) {
@@ -1022,7 +1022,7 @@ const artic::Type* ArrayExpr::check(TypeChecker& checker, const artic::Type* exp
 
 const artic::Type* RepeatArrayExpr::infer(TypeChecker& checker) {
     auto elem_type = checker.deref(elem);
-    if (is_simd && !elem_type->isa<artic::PrimType>())
+    if (is_simd && !(elem_type->template isa<artic::PrimType>() || elem_type->template isa<artic::PtrType>()))
         return checker.invalid_simd(loc, elem_type);
 
     if (std::holds_alternative<ast::Path>(size)) {

src/emit.cpp

@@ -1885,8 +1885,17 @@ std::string SizedArrayType::stringify(Emitter& emitter) const {
 }
 
 const thorin::Type* SizedArrayType::convert(Emitter& emitter) const {
-    if (is_simd)
-        return emitter.world.prim_type(elem->convert(emitter)->as<thorin::PrimType>()->primtype_tag(), size);
+    if (is_simd) {
+        auto elem_type = elem->convert(emitter);
+        if (auto prim_type = elem_type->isa<thorin::PrimType>())
+            return emitter.world.prim_type(prim_type->primtype_tag(), size);
+        else if (auto ptr_type = elem_type->isa<thorin::PtrType>())
+            return emitter.world.ptr_type(ptr_type->pointee(), size, ptr_type->addr_space());
+
+        //This should be unreachable after type checking.
+        assert(false);
+        return nullptr;
+    }
     return emitter.world.definite_array_type(elem->convert(emitter), size);
 }