mt-lang 0.3.22 → 0.3.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6dc76fcf0acde63fa4060157d6c6864dedcc32b0f5c2cd60422e9948d9861dab
-  data.tar.gz: 0b1bf5aee4d6be4d0f1968a7dacaf35e37557336a5911834a17324d23bd60ba3
+  metadata.gz: 7cfa07273d22ec7c182da079791513e546752f942e99e85d4ae68c3596a1dd96
+  data.tar.gz: 8ca9fb2fa55d9f2a7e9db9dd1f6935a0a82c8ad0f87f907b865007d5a27b68db
 SHA512:
-  metadata.gz: 1b34537660a1c2424b3f829ff6ef18d35de4366fe76d0a0938216261b1f9c7c56d8fce2c8a0ac1162f17ddc8c1a2c565f9e08f2f5f0056624f4959d35833cabf
-  data.tar.gz: 9b6b00b5b761ab3128c617acb8398c64b829df1e2d6984661bc6e8bfb2081b9fa408fd5e8774e1b540884a59caef4eef146c3a05f0d176cb62019471b4e28b88
+  metadata.gz: 0f8b9f5966a1bb53bfcf618293fdff445031610f97c316db745db6a06e3e32c50206fde9776b57ef205baab5c1ee240b11e0c003f9bed72d14f6f256d767b6d6
+  data.tar.gz: 50bd110c31a30966d1a25560c14e239ffee4f99e4991efd6a3029bb4dd6a05cea2d65c58e35dda94b917ec25ba1d7750e8d7e2d4578d1862b926dadfb4ab8f4b

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.3.22"
+  VERSION = "0.3.23"
 
   def self.root
     @root ||= Pathname.new(File.expand_path("../..", __dir__))

data/lib/milk_tea/core/semantic_analyzer/analysis_context.rb

@@ -289,6 +289,31 @@ module MilkTea
         closest_dist <= max_distance ? closest : nil
       end
 
+      # Common std-library types that are usually used bare. When one of these
+      # names is unresolved, the compiler points at the module that exports it
+      # instead of leaving a generic "unknown name" diagnostic.
+      STD_TYPE_IMPORT_HINTS = {
+        "String" => "std.string",
+        "Vec" => "std.vec",
+        "Deque" => "std.deque",
+        "Map" => "std.map",
+        "Set" => "std.set",
+        "LinkedMap" => "std.linked_map",
+        "LinkedSet" => "std.linked_set",
+        "OrderedMap" => "std.ordered_map",
+        "OrderedSet" => "std.ordered_set",
+        "BinaryHeap" => "std.binary_heap",
+        "PriorityQueue" => "std.priority_queue",
+        "Counter" => "std.counter",
+      }.freeze
+
+      def import_hint_for_known_std_name(name)
+        module_path = STD_TYPE_IMPORT_HINTS[name.to_s]
+        return nil unless module_path
+
+        "type '#{name}' is available via 'import #{module_path}'"
+      end
+
       def levenshtein(s, t)
         m = s.length
         n = t.length

data/lib/milk_tea/core/semantic_analyzer/expressions.rb

@@ -336,6 +336,9 @@ module MilkTea
           scoped_names = scopes.flat_map { |s| s.is_a?(Hash) ? s.keys : [] }.map(&:to_s)
           suggestion = suggest_name(expression.name, func_names + type_names + scoped_names)
         end
+        if (import_hint = import_hint_for_known_std_name(expression.name))
+          raise_sema_error("unknown name #{expression.name}; #{import_hint}")
+        end
         raise_sema_error("unknown name #{expression.name}", expression, suggestion: suggestion ? "did you mean '#{suggestion}'?" : nil)
       end
 
@@ -1505,6 +1508,9 @@ module MilkTea
               raise_sema_error("unsupported format spec #{part.format_spec.inspect}")
             end
           else
+            if string_builder_type?(value_type)
+              raise_sema_error("formatted string interpolation does not support #{value_type}; interpolate #{describe_expression(part.expression)}.as_str() instead, or append into it with .append_format(f\"...\")")
+            end
             next if format_string_interpolation_supported?(value_type, context: "formatted string interpolation of #{value_type}")
             raise_sema_error("formatted string interpolation supports str, cstr, bool, numeric primitives, integer-backed enums/flags, and types implementing format_len()/append_format(output: ref[std.string.String]), got #{value_type}")
           end

data/lib/milk_tea/core/semantic_analyzer/name_resolution.rb

@@ -365,6 +365,9 @@ module MilkTea
           unless suggestion
             suggestion = import_suggestion_for_type(name)
           end
+          unless suggestion
+            suggestion = import_hint_for_known_std_name(name)
+          end
           raise_sema_error("unknown type #{name}", type_ref, suggestion: suggestion ? "did you mean '#{suggestion}'?" : nil)
         end
         raise_sema_error("generic type #{name} requires type arguments", type_ref) if type.is_a?(Types::GenericStructDefinition) || type.is_a?(Types::GenericVariantDefinition)
@@ -638,6 +641,7 @@ module MilkTea
       def infer_layout_query_type(type_ref, context:)
         type = resolve_type_ref(type_ref)
         return type if sized_layout_type?(type)
+        return type if vector_type?(type) || matrix_type?(type) || quaternion_type?(type) || simd_type?(type)
 
         raise_sema_error("#{context} requires a concrete sized type, got #{type_ref}")
       end

data/lib/milk_tea/core/semantic_analyzer/type_compatibility.rb

@@ -266,6 +266,7 @@ module MilkTea
 
       def simd_bitwise_result(left_type, right_type)
         return nil unless simd_type?(left_type) && simd_type?(right_type) && left_type == right_type
+        return nil unless left_type.element_type.integer?
 
         left_type
       end
@@ -286,15 +287,16 @@ module MilkTea
 
       def vector_op_result(operator, left_type, right_type)
         if vector_type?(left_type) && vector_type?(right_type) && left_type.element_type == right_type.element_type
+          return nil unless left_type.width == right_type.width
           return left_type if operator == "+" || operator == "-"
           return left_type if operator == "*"
         end
 
-        if vector_type?(left_type) && right_type.numeric?
+        if vector_type?(left_type) && primitive_numeric_type?(right_type)
           return left_type if operator == "*" || operator == "/"
         end
 
-        if left_type.numeric? && vector_type?(right_type) && operator == "*"
+        if primitive_numeric_type?(left_type) && vector_type?(right_type) && operator == "*"
           return right_type
         end
 
@@ -307,11 +309,7 @@ module MilkTea
           return left_type if operator == "*"
         end
 
-        if matrix_type?(left_type) && vector_type?(right_type) && left_type.dim == right_type.width && right_type.element_type == Types::BUILTIN_VECTOR_ELEMENT
-          return Types::Vector.new(right_type.name, element_type: right_type.element_type, width: right_type.width) if operator == "*"
-        end
-
-        if matrix_type?(left_type) && right_type.numeric?
+        if matrix_type?(left_type) && primitive_numeric_type?(right_type)
           return left_type if operator == "*" || operator == "/"
         end
 
@@ -324,13 +322,13 @@ module MilkTea
           return left_type if operator == "*"
         end
 
-        if quaternion_type?(left_type) && vector_type?(right_type) && right_type.width == 3 && right_type.element_type == Types::BUILTIN_VECTOR_ELEMENT
-          return right_type if operator == "*"
-        end
-
         nil
       end
 
+      def primitive_numeric_type?(type)
+        type.is_a?(Types::Primitive) && type.numeric?
+      end
+
       def pointer_cast?(source_type, target_type)
         pointer_cast_type?(source_type) && pointer_cast_type?(target_type)
       end

data/lib/milk_tea/core/types/layout.rb

@@ -76,6 +76,21 @@ module MilkTea
         total = element_layout.first * type.lane_count
         alignment = total > 16 ? 32 : 16
         [total, alignment]
+      when Types::Vector
+        element_layout = size_and_alignment(type.element_type, stack)
+        return unless element_layout
+
+        [element_layout.first * type.width, element_layout.last]
+      when Types::Matrix
+        element_layout = size_and_alignment(Types::BUILTIN_VECTOR_ELEMENT, stack)
+        return unless element_layout
+
+        [element_layout.first * type.dim * type.dim, element_layout.last]
+      when Types::Quaternion
+        element_layout = size_and_alignment(Types::BUILTIN_VECTOR_ELEMENT, stack)
+        return unless element_layout
+
+        [element_layout.first * 4, element_layout.last]
       else
         nil
       end

data/lib/milk_tea/core/types/predicates.rb

@@ -100,9 +100,14 @@ module MilkTea
           return value.abs <= (1 << 24) if value.is_a?(Integer)
 
           exactly_representable_float32?(value.to_f)
-        else
-          return true if expected_type.name == "double"
+        elsif expected_type.name == "double"
+          # Every integer with magnitude <= 2^53 is exactly representable in
+          # double precision; larger integer constants would lose precision, so
+          # they require an explicit cast instead.
+          return value.abs <= (1 << 53) if value.is_a?(Integer)
 
+          true
+        else
           false
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.22
+  version: 0.3.23
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -625,7 +625,7 @@ metadata:
   homepage_uri: https://teefan.github.io/mt-lang/
   source_code_uri: https://github.com/teefan/mt-lang
 post_install_message: |
-  Milk Tea 0.3.22 installed!
+  Milk Tea 0.3.23 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH