usize indexing only

compiler/checker/checker.odin

@@ -5108,7 +5108,8 @@ infer_compound_expr :: proc(
 		return types.child_type(value, store) if types.is_pointer(value, store) else types.INVALID
 	case .Index:
 		value := infer_nested_expr(checker, expr.left, locals, pkg, file, demanded, local_types)
-		_ = infer_nested_expr(checker, expr.right, locals, pkg, file, demanded, local_types)
+		_ = infer_nested_expr(checker, expr.right, locals, pkg, file, demanded, local_types, types.USIZE)
+		_ = record_demand(checker, expr.right, types.USIZE, locals, local_types, pkg, file)
 		item, ok := types.container(value, store)
 		return item.child if ok else types.INVALID
 	case .Slice:
@@ -5124,7 +5125,8 @@ infer_compound_expr :: proc(
 		}
 		for bound in expr.args {
 			if bound != ast.INVALID_EXPR {
-				_ = infer_nested_expr(checker, bound, locals, pkg, file, demanded, local_types)
+				_ = infer_nested_expr(checker, bound, locals, pkg, file, demanded, local_types, types.USIZE)
+				_ = record_demand(checker, bound, types.USIZE, locals, local_types, pkg, file)
 			}
 		}
 		preserve := item.has_sentinel && expr.args[1] == ast.INVALID_EXPR
@@ -8100,36 +8102,35 @@ build_scalar_cast :: proc(
 		diagnostic=source.INVALID_DIAGNOSTIC,
 	})
 }
-normalize_index_expr :: proc(checker: ^Checker, value: hir.Expr_Id, span: source.Span) -> hir.Expr_Id {
-	store := &checker.module.types
-	current := value
-	current_type := checker.module.exprs[current].type
-	representation, distinct_ok := types.distinct_scalar_backing(current_type, store)
-	if distinct_ok && types.is_concrete_integer(representation) {
-		for {
-			backing, ok := types.distinct_backing(current_type, store)
-			if !ok {
-				break
-			}
-			current = add_hir_expr(checker, hir.Expr{
-				kind=.Retype,
-				span=span,
-				type=backing,
-				left=current,
-				target=hir.INVALID_REF,
-				right=hir.INVALID_EXPR,
-				diagnostic=source.INVALID_DIAGNOSTIC,
-			})
-			current_type = backing
-		}
+normalize_index_expr :: proc(
+	checker: ^Checker,
+	value: hir.Expr_Id,
+	span: source.Span,
+	label: string,
+) -> hir.Expr_Id {
+	if value == hir.INVALID_EXPR {
+		return value
 	}
-	current_expr := &checker.module.exprs[current]
+	if _, invalid := invalid_expr_diagnostic(checker, value); invalid {
+		return value
+	}
+	current_expr := &checker.module.exprs[value]
 	if current_expr.kind == .Integer &&
 	   fits_integer_type(i128(current_expr.integer), types.USIZE, checker.target) {
 		current_expr.type = types.USIZE
-		return current
+		return value
 	}
-	return coerce_expr(checker, current, types.USIZE, span)
+	if !types.equal(current_expr.type, types.USIZE) {
+		id := source.addf(
+			checker.diagnostics,
+			span,
+			"%s must have type usize, got %s",
+			label,
+			type_label(checker, current_expr.type),
+		)
+		return invalid_hir_expr(checker, span, id, types.USIZE)
+	}
+	return value
 }
 
 
@@ -8690,7 +8691,7 @@ build_compound_expr :: proc(
 	case .Index:
 		container := build_nested_expr(checker, expr.left, locals, global_reads, calls, types.INVALID, pkg, file)
 		index := build_nested_expr(checker, expr.right, locals, global_reads, calls, types.INVALID, pkg, file)
-		index = normalize_index_expr(checker, index, expr.span)
+		index = normalize_index_expr(checker, index, expr.span, "index")
 		if invalid, propagated := propagate_invalid_expr(checker, expr.span, container, index); propagated {
 			return invalid
 		}
@@ -8734,7 +8735,12 @@ build_compound_expr :: proc(
 		for bound, index in expr.args {
 			if bound != ast.INVALID_EXPR {
 				bounds[index] = build_nested_expr(checker, bound, locals, global_reads, calls, types.INVALID, pkg, file)
-				bounds[index] = normalize_index_expr(checker, bounds[index], checker.ast_module.exprs[bound].span)
+				bounds[index] = normalize_index_expr(
+					checker,
+					bounds[index],
+					checker.ast_module.exprs[bound].span,
+					"slice bound",
+				)
 				if invalid, propagated := propagate_invalid_expr(checker, expr.span, bounds[index]); propagated {
 					delete(bounds, checker.allocator)
 					return invalid