mt-lang 0.3.34 → 0.3.38

data/lib/milk_tea/lsp/server/inlay_hints.rb

@@ -108,13 +108,11 @@ module MilkTea
         def collect_inferred_type_hints(facts, start_line, start_char, end_line, end_char)
           hints = []
           collect_local_decls(facts.ast).each do |decl|
+            next unless decl.name && decl.name != '_'
             next unless decl.type.nil?
             next unless position_in_range?(decl.line - 1, decl.column - 1, start_line, start_char, end_line, end_char)
 
-            binding = facts.values[decl.name]
-            next unless binding
-
-            display_type = describe_type_for_hint(binding.storage_type)
+            display_type = resolved_decl_type_detail(decl, facts)
             next unless display_type
 
             hints << {
@@ -127,20 +125,30 @@ module MilkTea
           hints
         end
 
+        # Resolves the declared type of an inferred local from semantic facts so
+        # the hint reflects flow refinement (let/var ... else:, ?-propagation).
+        def resolved_decl_type_detail(decl, facts)
+          resolution = facts.respond_to?(:binding_resolution) ? facts.binding_resolution : nil
+          return nil unless resolution
+
+          binding_id = resolution.declaration_binding_ids[decl.object_id]
+          return nil unless binding_id
+
+          type = resolution.binding_types[binding_id]
+          return nil if type.is_a?(Types::Error)
+
+          short_type_detail(type)
+        end
+
         def collect_inferred_return_hints(facts, start_line, start_char, end_line, end_char)
           hints = []
           collect_function_defs(facts.ast).each do |func|
             next unless func.return_type.nil?
             next unless position_in_range?(func.line - 1, func.column - 1, start_line, start_char, end_line, end_char)
 
-            binding = facts.functions[func.name]
-            unless binding
-              facts.imports.each_value do |mod|
-                binding = mod.functions[func.name]
-                break if binding
-              end
-            end
+            binding = resolve_function_binding(facts, func)
             next unless binding
+            next unless binding.respond_to?(:type) && binding.type.respond_to?(:return_type)
 
             return_type = binding.type.return_type
             next unless return_type
@@ -160,6 +168,20 @@ module MilkTea
           hints
         end
 
+        def resolve_function_binding(facts, func)
+          name = func.name
+          if func.is_a?(AST::MethodDef)
+            facts.methods.each_value do |methods|
+              binding = methods[name] || methods["static:#{name}"]
+              return binding if binding
+            end
+            return nil
+          end
+
+          facts.functions[name] ||
+            facts.imports.each_value.find { |mod| mod.functions.key?(name) }&.functions&.dig(name)
+        end
+
         def collect_local_decls(ast_node)
           results = []
           case ast_node

data/lib/milk_tea/lsp/server/selection_range.rb

@@ -24,7 +24,7 @@ module MilkTea
           line_str = lines[lsp_line] || ""
           return nil if line_str.empty?
 
-          token_range = token_bounds_at(line_str, lsp_char)
+          token_range = token_bounds_at(line_str, lsp_line, lsp_char)
           line_range = { start: { line: lsp_line, character: 0 },
                          end: { line: lsp_line, character: line_str.length } }
 
@@ -47,7 +47,7 @@ module MilkTea
           current
         end
 
-        def token_bounds_at(line_str, lsp_char)
+        def token_bounds_at(line_str, lsp_line, lsp_char)
           col = [lsp_char, line_str.length - 1].min
           col = [col, 0].max
 
@@ -61,8 +61,8 @@ module MilkTea
           return nil if left == right && line_str[left] !~ /[A-Za-z0-9_]/
 
           {
-            start: { line: 0, character: left },
-            end: { line: 0, character: right + 1 },
+            start: { line: lsp_line, character: left },
+            end: { line: lsp_line, character: right + 1 },
           }
         end
 

data/lib/milk_tea/lsp/server/semantic_tokens.rb

@@ -18,7 +18,7 @@ module MilkTea
             short_uri = shorten_uri(uri) || uri
             log_perf_breakdown('textDocument/semanticTokens/full', elapsed,
                               "uri=#{short_uri} bytes=#{content.bytesize} lines=#{content.count("\n") + 1} cache=hit data_len=#{cached[:data].length}")
-            return { data: cached[:data] }
+            return { resultId: cached[:result_id], data: cached[:data] }
           end
 
           tokens_start = monotonic_time
@@ -37,9 +37,8 @@ module MilkTea
           data = encode_semantic_tokens(semantic_entries)
           encode_ms = elapsed_ms(encode_start)
 
-          @semantic_tokens_cache[uri] = { content_hash: cache_key, data: data }
-
           result_id = next_semantic_token_result_id(uri)
+          @semantic_tokens_cache[uri] = { content_hash: cache_key, data: data, result_id: result_id }
           @semantic_tokens_delta_cache[uri] = {
             result_id: result_id,
             content_hash: cache_key,
@@ -51,7 +50,7 @@ module MilkTea
           log_perf_breakdown('textDocument/semanticTokens/full', elapsed,
                             "uri=#{short_uri} bytes=#{content.bytesize} lines=#{content.count("\n") + 1} cache=miss tokens=#{tokens.length} entries=#{semantic_entries.length} data_len=#{data.length} facts=on stages_ms=tokens:#{tokens_ms},facts:#{facts_ms},build:#{build_ms},encode:#{encode_ms}")
 
-          { data: data }
+          { resultId: result_id, data: data }
         rescue StandardError => e
           warn "Error in semanticTokens/full handler: #{e.message}"
           { data: [] }
@@ -1745,7 +1744,12 @@ module MilkTea
 
           start_offset = prefix * 5
           delete_count = old_mid * 5
-          insert_tokens = encode_semantic_tokens(new_entries[prefix...(new_entries.length - suffix)])
+
+          # The inserted segment must keep the relative encoding against the
+          # last unchanged token preceding the edit, so encode the full token
+          # stream from the document origin and slice out the middle segment.
+          full_encoded = encode_semantic_tokens(new_entries)
+          insert_tokens = full_encoded[start_offset...(new_entries.length - suffix) * 5]
 
           [{ start: start_offset, deleteCount: delete_count, data: insert_tokens }]
         end

data/lib/milk_tea/lsp/server/type_hierarchy.rb

@@ -5,11 +5,11 @@ module MilkTea
     class Server
       module ServerTypeHierarchy
         TYPE_KIND_MAP = {
-          struct: 22,
-          enum: 13,
-          flags: 13,
-          variant: 13,
-          union: 22,
+          struct: 23,
+          enum: 10,
+          flags: 10,
+          variant: 23,
+          union: 23,
           interface: 11,
         }.freeze
 

data/lib/milk_tea/packages/manifest.rb

@@ -42,6 +42,15 @@ module MilkTea
       new(path).load
     end
 
+    # Best-effort manifest load for optional lookups: returns nil when no
+    # manifest applies to the path or when the manifest is invalid, instead
+    # of raising PackageManifestError.
+    def self.load_option(path)
+      load(path)
+    rescue PackageManifestError
+      nil
+    end
+
     def self.manifest_exists_for?(path)
       path = File.expand_path(path)
       current = File.directory?(path) ? path : File.dirname(path)

data/lib/milk_tea/tooling/linter/visitors.rb

@@ -846,7 +846,10 @@ module MilkTea
         return false unless else_body
         text << else_body
 
-        text.strip.length > 120
+        # The inline form would start at the `if` keyword's column, so the real
+        # line width includes the surrounding block's indentation.
+        indent = statement.branches.first.column.to_i - 1
+        (indent + text.strip.length) > 120
       end
 
       def source_line_from(line, column)

data/std/box2d.mt

@@ -111,9 +111,9 @@ public const B2_PI: float = c.B2_PI
 public const B2_MAX_POLYGON_VERTICES: int = c.B2_MAX_POLYGON_VERTICES
 public const B2_DEFAULT_CATEGORY_BITS: int = c.B2_DEFAULT_CATEGORY_BITS
 
-public foreign function set_allocator(alloc_fcn: ptr[AllocFcn], free_fcn: ptr[FreeFcn]) -> void = c.b2SetAllocator
+public foreign function set_allocator(alloc_fcn: AllocFcn, free_fcn: FreeFcn) -> void = c.b2SetAllocator
 public foreign function get_byte_count() -> int = c.b2GetByteCount
-public foreign function set_assert_fcn(assert_fcn: ptr[AssertFcn]) -> void = c.b2SetAssertFcn
+public foreign function set_assert_fcn(assert_fcn: AssertFcn) -> void = c.b2SetAssertFcn
 public foreign function get_version() -> Version = c.b2GetVersion
 public foreign function internal_assert_fcn(condition: str as cstr, file_name: str as cstr, line_number: int) -> int = c.b2InternalAssertFcn
 public foreign function get_ticks() -> ulong = c.b2GetTicks
@@ -188,9 +188,9 @@ public foreign function dynamic_tree_move_proxy(tree: ptr[DynamicTree], proxy_id
 public foreign function dynamic_tree_enlarge_proxy(tree: ptr[DynamicTree], proxy_id: int, aabb: AABB) -> void = c.b2DynamicTree_EnlargeProxy
 public foreign function dynamic_tree_set_category_bits(tree: ptr[DynamicTree], proxy_id: int, category_bits: ptr_uint) -> void = c.b2DynamicTree_SetCategoryBits
 public foreign function dynamic_tree_get_category_bits(tree: ptr[DynamicTree], proxy_id: int) -> ulong = c.b2DynamicTree_GetCategoryBits
-public foreign function dynamic_tree_query(tree: const_ptr[DynamicTree], aabb: AABB, mask_bits: ptr_uint, callback: ptr[TreeQueryCallbackFcn], context: ptr[void]) -> TreeStats = c.b2DynamicTree_Query
-public foreign function dynamic_tree_ray_cast(tree: const_ptr[DynamicTree], input: const_ptr[RayCastInput], mask_bits: ptr_uint, callback: ptr[TreeRayCastCallbackFcn], context: ptr[void]) -> TreeStats = c.b2DynamicTree_RayCast
-public foreign function dynamic_tree_shape_cast(tree: const_ptr[DynamicTree], input: const_ptr[ShapeCastInput], mask_bits: ptr_uint, callback: ptr[TreeShapeCastCallbackFcn], context: ptr[void]) -> TreeStats = c.b2DynamicTree_ShapeCast
+public foreign function dynamic_tree_query(tree: const_ptr[DynamicTree], aabb: AABB, mask_bits: ptr_uint, callback: TreeQueryCallbackFcn, context: ptr[void]) -> TreeStats = c.b2DynamicTree_Query
+public foreign function dynamic_tree_ray_cast(tree: const_ptr[DynamicTree], input: const_ptr[RayCastInput], mask_bits: ptr_uint, callback: TreeRayCastCallbackFcn, context: ptr[void]) -> TreeStats = c.b2DynamicTree_RayCast
+public foreign function dynamic_tree_shape_cast(tree: const_ptr[DynamicTree], input: const_ptr[ShapeCastInput], mask_bits: ptr_uint, callback: TreeShapeCastCallbackFcn, context: ptr[void]) -> TreeStats = c.b2DynamicTree_ShapeCast
 public foreign function dynamic_tree_get_height(tree: const_ptr[DynamicTree]) -> int = c.b2DynamicTree_GetHeight
 public foreign function dynamic_tree_get_area_ratio(tree: const_ptr[DynamicTree]) -> float = c.b2DynamicTree_GetAreaRatio
 public foreign function dynamic_tree_get_root_bounds(tree: const_ptr[DynamicTree]) -> AABB = c.b2DynamicTree_GetRootBounds
@@ -228,13 +228,13 @@ public foreign function world_draw(world_id: WorldId, inout draw: DebugDraw) ->
 public foreign function world_get_body_events(world_id: WorldId) -> BodyEvents = c.b2World_GetBodyEvents
 public foreign function world_get_sensor_events(world_id: WorldId) -> SensorEvents = c.b2World_GetSensorEvents
 public foreign function world_get_contact_events(world_id: WorldId) -> ContactEvents = c.b2World_GetContactEvents
-public foreign function world_overlap_aabb(world_id: WorldId, aabb: AABB, filter: QueryFilter, fcn: ptr[OverlapResultFcn], context: ptr[void]) -> TreeStats = c.b2World_OverlapAABB
-public foreign function world_overlap_shape(world_id: WorldId, proxy: const_ptr[ShapeProxy], filter: QueryFilter, fcn: ptr[OverlapResultFcn], context: ptr[void]) -> TreeStats = c.b2World_OverlapShape
-public foreign function world_cast_ray(world_id: WorldId, origin: Vec2, translation: Vec2, filter: QueryFilter, fcn: ptr[CastResultFcn], context: ptr[void]) -> TreeStats = c.b2World_CastRay
+public foreign function world_overlap_aabb(world_id: WorldId, aabb: AABB, filter: QueryFilter, fcn: OverlapResultFcn, context: ptr[void]) -> TreeStats = c.b2World_OverlapAABB
+public foreign function world_overlap_shape(world_id: WorldId, proxy: const_ptr[ShapeProxy], filter: QueryFilter, fcn: OverlapResultFcn, context: ptr[void]) -> TreeStats = c.b2World_OverlapShape
+public foreign function world_cast_ray(world_id: WorldId, origin: Vec2, translation: Vec2, filter: QueryFilter, fcn: CastResultFcn, context: ptr[void]) -> TreeStats = c.b2World_CastRay
 public foreign function world_cast_ray_closest(world_id: WorldId, origin: Vec2, translation: Vec2, filter: QueryFilter) -> RayResult = c.b2World_CastRayClosest
-public foreign function world_cast_shape(world_id: WorldId, proxy: const_ptr[ShapeProxy], translation: Vec2, filter: QueryFilter, fcn: ptr[CastResultFcn], context: ptr[void]) -> TreeStats = c.b2World_CastShape
+public foreign function world_cast_shape(world_id: WorldId, proxy: const_ptr[ShapeProxy], translation: Vec2, filter: QueryFilter, fcn: CastResultFcn, context: ptr[void]) -> TreeStats = c.b2World_CastShape
 public foreign function world_cast_mover(world_id: WorldId, mover: const_ptr[Capsule], translation: Vec2, filter: QueryFilter) -> float = c.b2World_CastMover
-public foreign function world_collide_mover(world_id: WorldId, mover: const_ptr[Capsule], filter: QueryFilter, fcn: ptr[PlaneResultFcn], context: ptr[void]) -> void = c.b2World_CollideMover
+public foreign function world_collide_mover(world_id: WorldId, mover: const_ptr[Capsule], filter: QueryFilter, fcn: PlaneResultFcn, context: ptr[void]) -> void = c.b2World_CollideMover
 public foreign function world_enable_sleeping(world_id: WorldId, flag: bool) -> void = c.b2World_EnableSleeping
 public foreign function world_is_sleeping_enabled(world_id: WorldId) -> bool = c.b2World_IsSleepingEnabled
 public foreign function world_enable_continuous(world_id: WorldId, flag: bool) -> void = c.b2World_EnableContinuous
@@ -243,8 +243,8 @@ public foreign function world_set_restitution_threshold(world_id: WorldId, value
 public foreign function world_get_restitution_threshold(world_id: WorldId) -> float = c.b2World_GetRestitutionThreshold
 public foreign function world_set_hit_event_threshold(world_id: WorldId, value: float) -> void = c.b2World_SetHitEventThreshold
 public foreign function world_get_hit_event_threshold(world_id: WorldId) -> float = c.b2World_GetHitEventThreshold
-public foreign function world_set_custom_filter_callback(world_id: WorldId, fcn: ptr[CustomFilterFcn], context: ptr[void]) -> void = c.b2World_SetCustomFilterCallback
-public foreign function world_set_pre_solve_callback(world_id: WorldId, fcn: ptr[PreSolveFcn], context: ptr[void]) -> void = c.b2World_SetPreSolveCallback
+public foreign function world_set_custom_filter_callback(world_id: WorldId, fcn: CustomFilterFcn, context: ptr[void]) -> void = c.b2World_SetCustomFilterCallback
+public foreign function world_set_pre_solve_callback(world_id: WorldId, fcn: PreSolveFcn, context: ptr[void]) -> void = c.b2World_SetPreSolveCallback
 public foreign function world_set_gravity(world_id: WorldId, gravity: Vec2) -> void = c.b2World_SetGravity
 public foreign function world_get_gravity(world_id: WorldId) -> Vec2 = c.b2World_GetGravity
 public foreign function world_explode(world_id: WorldId, in explosion_def: ExplosionDef) -> void = c.b2World_Explode
@@ -258,8 +258,8 @@ public foreign function world_get_profile(world_id: WorldId) -> Profile = c.b2Wo
 public foreign function world_get_counters(world_id: WorldId) -> Counters = c.b2World_GetCounters
 public foreign function world_set_user_data(world_id: WorldId, user_data: ptr[void]) -> void = c.b2World_SetUserData
 public foreign function world_get_user_data(world_id: WorldId) -> ptr[void] = c.b2World_GetUserData
-public foreign function world_set_friction_callback(world_id: WorldId, callback: ptr[FrictionCallback]) -> void = c.b2World_SetFrictionCallback
-public foreign function world_set_restitution_callback(world_id: WorldId, callback: ptr[RestitutionCallback]) -> void = c.b2World_SetRestitutionCallback
+public foreign function world_set_friction_callback(world_id: WorldId, callback: FrictionCallback) -> void = c.b2World_SetFrictionCallback
+public foreign function world_set_restitution_callback(world_id: WorldId, callback: RestitutionCallback) -> void = c.b2World_SetRestitutionCallback
 public foreign function world_dump_memory_stats(world_id: WorldId) -> void = c.b2World_DumpMemoryStats
 public foreign function world_rebuild_static_tree(world_id: WorldId) -> void = c.b2World_RebuildStaticTree
 public foreign function world_enable_speculative(world_id: WorldId, flag: bool) -> void = c.b2World_EnableSpeculative

data/std/c/box2d.mt

@@ -10,9 +10,9 @@ type b2AllocFcn = fn(arg0: uint, arg1: int) -> ptr[void]
 type b2FreeFcn = fn(arg0: ptr[void]) -> void
 type b2AssertFcn = fn(arg0: cstr, arg1: cstr, arg2: int) -> int
 
-external function b2SetAllocator(allocFcn: ptr[b2AllocFcn], freeFcn: ptr[b2FreeFcn]) -> void
+external function b2SetAllocator(allocFcn: b2AllocFcn, freeFcn: b2FreeFcn) -> void
 external function b2GetByteCount() -> int
-external function b2SetAssertFcn(assertFcn: ptr[b2AssertFcn]) -> void
+external function b2SetAssertFcn(assertFcn: b2AssertFcn) -> void
 
 struct b2Version:
     major: int
@@ -313,15 +313,15 @@ external function b2DynamicTree_GetCategoryBits(tree: ptr[b2DynamicTree], proxyI
 
 type b2TreeQueryCallbackFcn = fn(arg0: int, arg1: ulong, arg2: ptr[void]) -> bool
 
-external function b2DynamicTree_Query(tree: const_ptr[b2DynamicTree], aabb: b2AABB, maskBits: ptr_uint, callback: ptr[b2TreeQueryCallbackFcn], context: ptr[void]) -> b2TreeStats
+external function b2DynamicTree_Query(tree: const_ptr[b2DynamicTree], aabb: b2AABB, maskBits: ptr_uint, callback: b2TreeQueryCallbackFcn, context: ptr[void]) -> b2TreeStats
 
 type b2TreeRayCastCallbackFcn = fn(arg0: const_ptr[b2RayCastInput], arg1: int, arg2: ulong, arg3: ptr[void]) -> float
 
-external function b2DynamicTree_RayCast(tree: const_ptr[b2DynamicTree], input: const_ptr[b2RayCastInput], maskBits: ptr_uint, callback: ptr[b2TreeRayCastCallbackFcn], context: ptr[void]) -> b2TreeStats
+external function b2DynamicTree_RayCast(tree: const_ptr[b2DynamicTree], input: const_ptr[b2RayCastInput], maskBits: ptr_uint, callback: b2TreeRayCastCallbackFcn, context: ptr[void]) -> b2TreeStats
 
 type b2TreeShapeCastCallbackFcn = fn(arg0: const_ptr[b2ShapeCastInput], arg1: int, arg2: ulong, arg3: ptr[void]) -> float
 
-external function b2DynamicTree_ShapeCast(tree: const_ptr[b2DynamicTree], input: const_ptr[b2ShapeCastInput], maskBits: ptr_uint, callback: ptr[b2TreeShapeCastCallbackFcn], context: ptr[void]) -> b2TreeStats
+external function b2DynamicTree_ShapeCast(tree: const_ptr[b2DynamicTree], input: const_ptr[b2ShapeCastInput], maskBits: ptr_uint, callback: b2TreeShapeCastCallbackFcn, context: ptr[void]) -> b2TreeStats
 external function b2DynamicTree_GetHeight(tree: const_ptr[b2DynamicTree]) -> int
 external function b2DynamicTree_GetAreaRatio(tree: const_ptr[b2DynamicTree]) -> float
 external function b2DynamicTree_GetRootBounds(tree: const_ptr[b2DynamicTree]) -> b2AABB
@@ -382,7 +382,7 @@ const b2_nullChainId: b2ChainId = b2ChainId(index1 = 0, world0 = 0, generation =
 const b2_nullJointId: b2JointId = b2JointId(index1 = 0, world0 = 0, generation = 0)
 
 type b2TaskCallback = fn(arg0: int, arg1: int, arg2: uint, arg3: ptr[void]) -> void
-type b2EnqueueTaskCallback = fn(arg0: ptr[b2TaskCallback], arg1: int, arg2: int, arg3: ptr[void], arg4: ptr[void]) -> ptr[void]
+type b2EnqueueTaskCallback = fn(arg0: b2TaskCallback, arg1: int, arg2: int, arg3: ptr[void], arg4: ptr[void]) -> ptr[void]
 type b2FinishTaskCallback = fn(arg0: ptr[void], arg1: ptr[void]) -> void
 type b2FrictionCallback = fn(arg0: float, arg1: int, arg2: float, arg3: int) -> float
 type b2RestitutionCallback = fn(arg0: float, arg1: int, arg2: float, arg3: int) -> float
@@ -404,13 +404,13 @@ struct b2WorldDef:
     contactDampingRatio: float
     maxContactPushSpeed: float
     maximumLinearSpeed: float
-    frictionCallback: ptr[b2FrictionCallback]
-    restitutionCallback: ptr[b2RestitutionCallback]
+    frictionCallback: b2FrictionCallback
+    restitutionCallback: b2RestitutionCallback
     enableSleep: bool
     enableContinuous: bool
     workerCount: int
-    enqueueTask: ptr[b2EnqueueTaskCallback]
-    finishTask: ptr[b2FinishTaskCallback]
+    enqueueTask: b2EnqueueTaskCallback
+    finishTask: b2FinishTaskCallback
     userTaskContext: ptr[void]
     userData: ptr[void]
     internalValue: int
@@ -942,13 +942,13 @@ external function b2World_Draw(worldId: b2WorldId, draw: ptr[b2DebugDraw]) -> vo
 external function b2World_GetBodyEvents(worldId: b2WorldId) -> b2BodyEvents
 external function b2World_GetSensorEvents(worldId: b2WorldId) -> b2SensorEvents
 external function b2World_GetContactEvents(worldId: b2WorldId) -> b2ContactEvents
-external function b2World_OverlapAABB(worldId: b2WorldId, aabb: b2AABB, filter: b2QueryFilter, fcn: ptr[b2OverlapResultFcn], context: ptr[void]) -> b2TreeStats
-external function b2World_OverlapShape(worldId: b2WorldId, proxy: const_ptr[b2ShapeProxy], filter: b2QueryFilter, fcn: ptr[b2OverlapResultFcn], context: ptr[void]) -> b2TreeStats
-external function b2World_CastRay(worldId: b2WorldId, origin: b2Vec2, translation: b2Vec2, filter: b2QueryFilter, fcn: ptr[b2CastResultFcn], context: ptr[void]) -> b2TreeStats
+external function b2World_OverlapAABB(worldId: b2WorldId, aabb: b2AABB, filter: b2QueryFilter, fcn: b2OverlapResultFcn, context: ptr[void]) -> b2TreeStats
+external function b2World_OverlapShape(worldId: b2WorldId, proxy: const_ptr[b2ShapeProxy], filter: b2QueryFilter, fcn: b2OverlapResultFcn, context: ptr[void]) -> b2TreeStats
+external function b2World_CastRay(worldId: b2WorldId, origin: b2Vec2, translation: b2Vec2, filter: b2QueryFilter, fcn: b2CastResultFcn, context: ptr[void]) -> b2TreeStats
 external function b2World_CastRayClosest(worldId: b2WorldId, origin: b2Vec2, translation: b2Vec2, filter: b2QueryFilter) -> b2RayResult
-external function b2World_CastShape(worldId: b2WorldId, proxy: const_ptr[b2ShapeProxy], translation: b2Vec2, filter: b2QueryFilter, fcn: ptr[b2CastResultFcn], context: ptr[void]) -> b2TreeStats
+external function b2World_CastShape(worldId: b2WorldId, proxy: const_ptr[b2ShapeProxy], translation: b2Vec2, filter: b2QueryFilter, fcn: b2CastResultFcn, context: ptr[void]) -> b2TreeStats
 external function b2World_CastMover(worldId: b2WorldId, mover: const_ptr[b2Capsule], translation: b2Vec2, filter: b2QueryFilter) -> float
-external function b2World_CollideMover(worldId: b2WorldId, mover: const_ptr[b2Capsule], filter: b2QueryFilter, fcn: ptr[b2PlaneResultFcn], context: ptr[void]) -> void
+external function b2World_CollideMover(worldId: b2WorldId, mover: const_ptr[b2Capsule], filter: b2QueryFilter, fcn: b2PlaneResultFcn, context: ptr[void]) -> void
 external function b2World_EnableSleeping(worldId: b2WorldId, flag: bool) -> void
 external function b2World_IsSleepingEnabled(worldId: b2WorldId) -> bool
 external function b2World_EnableContinuous(worldId: b2WorldId, flag: bool) -> void
@@ -957,8 +957,8 @@ external function b2World_SetRestitutionThreshold(worldId: b2WorldId, value: flo
 external function b2World_GetRestitutionThreshold(worldId: b2WorldId) -> float
 external function b2World_SetHitEventThreshold(worldId: b2WorldId, value: float) -> void
 external function b2World_GetHitEventThreshold(worldId: b2WorldId) -> float
-external function b2World_SetCustomFilterCallback(worldId: b2WorldId, fcn: ptr[b2CustomFilterFcn], context: ptr[void]) -> void
-external function b2World_SetPreSolveCallback(worldId: b2WorldId, fcn: ptr[b2PreSolveFcn], context: ptr[void]) -> void
+external function b2World_SetCustomFilterCallback(worldId: b2WorldId, fcn: b2CustomFilterFcn, context: ptr[void]) -> void
+external function b2World_SetPreSolveCallback(worldId: b2WorldId, fcn: b2PreSolveFcn, context: ptr[void]) -> void
 external function b2World_SetGravity(worldId: b2WorldId, gravity: b2Vec2) -> void
 external function b2World_GetGravity(worldId: b2WorldId) -> b2Vec2
 external function b2World_Explode(worldId: b2WorldId, explosionDef: const_ptr[b2ExplosionDef]) -> void
@@ -972,8 +972,8 @@ external function b2World_GetProfile(worldId: b2WorldId) -> b2Profile
 external function b2World_GetCounters(worldId: b2WorldId) -> b2Counters
 external function b2World_SetUserData(worldId: b2WorldId, userData: ptr[void]) -> void
 external function b2World_GetUserData(worldId: b2WorldId) -> ptr[void]
-external function b2World_SetFrictionCallback(worldId: b2WorldId, callback: ptr[b2FrictionCallback]) -> void
-external function b2World_SetRestitutionCallback(worldId: b2WorldId, callback: ptr[b2RestitutionCallback]) -> void
+external function b2World_SetFrictionCallback(worldId: b2WorldId, callback: b2FrictionCallback) -> void
+external function b2World_SetRestitutionCallback(worldId: b2WorldId, callback: b2RestitutionCallback) -> void
 external function b2World_DumpMemoryStats(worldId: b2WorldId) -> void
 external function b2World_RebuildStaticTree(worldId: b2WorldId) -> void
 external function b2World_EnableSpeculative(worldId: b2WorldId, flag: bool) -> void

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.34
+  version: 0.3.38
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -624,7 +624,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.34 installed!
+  Milk Tea 0.3.38 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH
@@ -646,7 +646,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.18
 specification_version: 4
 summary: The Milk Tea programming language compiler toolchain
 test_files: []