Add files using upload-large-folder tool

projects/ui/serena-new/test/resources/repos/rust/test_repo_2024/src/main.rs

@@ -0,0 +1,19 @@
+fn main() {
+    println!("Hello, Rust 2024 edition!");
+    let result = add(2, 3);
+    println!("2 + 3 = {}", result);
+}
+
+pub fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_add() {
+        assert_eq!(add(2, 3), 5);
+    }
+}

projects/ui/serena-new/test/resources/repos/swift/test_repo/Package.swift

@@ -0,0 +1,16 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "test_repo",
+    products: [
+        .library(
+            name: "test_repo",
+            targets: ["test_repo"]),
+    ],
+    targets: [
+        .target(
+            name: "test_repo",
+            dependencies: []),
+    ]
+)

projects/ui/serena-new/test/resources/repos/swift/test_repo/src/main.swift

@@ -0,0 +1,62 @@
+import Foundation
+
+// Main entry point
+func main() {
+    let calculator = Calculator()
+    let result = calculator.add(5, 3)
+    print("Result: \(result)")
+    
+    let user = User(name: "Alice", age: 30)
+    user.greet()
+    
+    let area = Utils.calculateArea(radius: 5.0)
+    print("Circle area: \(area)")
+}
+
+class Calculator {
+    func add(_ a: Int, _ b: Int) -> Int {
+        return a + b
+    }
+    
+    func multiply(_ a: Int, _ b: Int) -> Int {
+        return a * b
+    }
+}
+
+struct User {
+    let name: String
+    let age: Int
+    
+    func greet() {
+        print("Hello, my name is \(name) and I am \(age) years old.")
+    }
+    
+    func isAdult() -> Bool {
+        return age >= 18
+    }
+}
+
+enum Status {
+    case active
+    case inactive
+    case pending
+}
+
+protocol Drawable {
+    func draw()
+}
+
+class Circle: Drawable {
+    let radius: Double
+    
+    init(radius: Double) {
+        self.radius = radius
+    }
+    
+    func draw() {
+        print("Drawing a circle with radius \(radius)")
+    }
+}
+
+// Call main
+main()

projects/ui/serena-new/test/resources/repos/swift/test_repo/src/utils.swift

@@ -0,0 +1,20 @@
+import Foundation
+
+public struct Utils {
+    public static func formatDate(_ date: Date) -> String {
+        let formatter = DateFormatter()
+        formatter.dateStyle = .medium
+        return formatter.string(from: date)
+    }
+    
+    public static func calculateArea(radius: Double) -> Double {
+        return Double.pi * radius * radius
+    }
+}
+
+public extension String {
+    func isValidEmail() -> Bool {
+        let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}"
+        return NSPredicate(format: "SELF MATCHES %@", emailRegex).evaluate(with: self)
+    }
+}

projects/ui/serena-new/test/resources/repos/terraform/test_repo/data.tf

@@ -0,0 +1,28 @@
+# Data sources for the Terraform configuration
+
+# Get the latest Ubuntu AMI
+data "aws_ami" "ubuntu" {
+  most_recent = true
+  owners      = ["099720109477"] # Canonical
+  
+  filter {
+    name   = "name"
+    values = ["ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*"]
+  }
+  
+  filter {
+    name   = "virtualization-type"
+    values = ["hvm"]
+  }
+}
+
+# Get available availability zones
+data "aws_availability_zones" "available" {
+  state = "available"
+}
+
+# Get current AWS caller identity
+data "aws_caller_identity" "current" {}
+
+# Get current AWS region
+data "aws_region" "current" {}

projects/ui/serena-new/test/resources/repos/terraform/test_repo/main.tf

@@ -0,0 +1,126 @@
+# Main Terraform configuration
+terraform {
+  required_version = ">= 1.0"
+  required_providers {
+    aws = {
+      source  = "hashicorp/aws"
+      version = "~> 5.0"
+    }
+  }
+}
+
+provider "aws" {
+  region = var.aws_region
+}
+
+# EC2 Instance
+resource "aws_instance" "web_server" {
+  ami           = data.aws_ami.ubuntu.id
+  instance_type = var.instance_type
+  
+  vpc_security_group_ids = [aws_security_group.web_sg.id]
+  subnet_id              = aws_subnet.public.id
+  
+  user_data = <<-EOF
+    #!/bin/bash
+    apt-get update
+    apt-get install -y nginx
+    systemctl start nginx
+    systemctl enable nginx
+  EOF
+  
+  tags = {
+    Name        = "${var.project_name}-web-server"
+    Environment = var.environment
+    Project     = var.project_name
+  }
+}
+
+# S3 Bucket
+resource "aws_s3_bucket" "app_bucket" {
+  bucket = "${var.project_name}-${var.environment}-bucket"
+  
+  tags = {
+    Name        = "${var.project_name}-bucket"
+    Environment = var.environment
+    Project     = var.project_name
+  }
+}
+
+resource "aws_s3_bucket_versioning" "app_bucket_versioning" {
+  bucket = aws_s3_bucket.app_bucket.id
+  versioning_configuration {
+    status = "Enabled"
+  }
+}
+
+# VPC
+resource "aws_vpc" "main" {
+  cidr_block           = "10.0.0.0/16"
+  enable_dns_hostnames = true
+  enable_dns_support   = true
+  
+  tags = {
+    Name        = "${var.project_name}-vpc"
+    Environment = var.environment
+    Project     = var.project_name
+  }
+}
+
+# Internet Gateway
+resource "aws_internet_gateway" "main" {
+  vpc_id = aws_vpc.main.id
+  
+  tags = {
+    Name        = "${var.project_name}-igw"
+    Environment = var.environment
+    Project     = var.project_name
+  }
+}
+
+# Public Subnet
+resource "aws_subnet" "public" {
+  vpc_id                  = aws_vpc.main.id
+  cidr_block              = "10.0.1.0/24"
+  availability_zone       = data.aws_availability_zones.available.names[0]
+  map_public_ip_on_launch = true
+  
+  tags = {
+    Name        = "${var.project_name}-public-subnet"
+    Environment = var.environment
+    Project     = var.project_name
+  }
+}
+
+# Security Group
+resource "aws_security_group" "web_sg" {
+  name_prefix = "${var.project_name}-web-"
+  vpc_id      = aws_vpc.main.id
+  
+  ingress {
+    from_port   = 80
+    to_port     = 80
+    protocol    = "tcp"
+    cidr_blocks = ["0.0.0.0/0"]
+  }
+  
+  ingress {
+    from_port   = 443
+    to_port     = 443
+    protocol    = "tcp"
+    cidr_blocks = ["0.0.0.0/0"]
+  }
+  
+  egress {
+    from_port   = 0
+    to_port     = 0
+    protocol    = "-1"
+    cidr_blocks = ["0.0.0.0/0"]
+  }
+  
+  tags = {
+    Name        = "${var.project_name}-web-sg"
+    Environment = var.environment
+    Project     = var.project_name
+  }
+}

projects/ui/serena-new/test/resources/repos/terraform/test_repo/outputs.tf

@@ -0,0 +1,46 @@
+# Output values for the Terraform configuration
+
+output "instance_id" {
+  description = "ID of the EC2 instance"
+  value       = aws_instance.web_server.id
+}
+
+output "instance_public_ip" {
+  description = "Public IP address of the EC2 instance"
+  value       = aws_instance.web_server.public_ip
+}
+
+output "instance_public_dns" {
+  description = "Public DNS name of the EC2 instance"
+  value       = aws_instance.web_server.public_dns
+}
+
+output "s3_bucket_name" {
+  description = "Name of the S3 bucket"
+  value       = aws_s3_bucket.app_bucket.bucket
+}
+
+output "s3_bucket_arn" {
+  description = "ARN of the S3 bucket"
+  value       = aws_s3_bucket.app_bucket.arn
+}
+
+output "vpc_id" {
+  description = "ID of the VPC"
+  value       = aws_vpc.main.id
+}
+
+output "subnet_id" {
+  description = "ID of the public subnet"
+  value       = aws_subnet.public.id
+}
+
+output "security_group_id" {
+  description = "ID of the security group"
+  value       = aws_security_group.web_sg.id
+}
+
+output "application_url" {
+  description = "URL to access the application"
+  value       = "http://${aws_instance.web_server.public_dns}"
+}

projects/ui/serena-new/test/resources/repos/terraform/test_repo/variables.tf

@@ -0,0 +1,61 @@
+# Input variables for the Terraform configuration
+
+variable "aws_region" {
+  description = "AWS region for resources"
+  type        = string
+  default     = "us-west-2"
+}
+
+variable "instance_type" {
+  description = "EC2 instance type"
+  type        = string
+  default     = "t3.micro"
+  
+  validation {
+    condition = contains([
+      "t3.micro", "t3.small", "t3.medium",
+      "t2.micro", "t2.small", "t2.medium"
+    ], var.instance_type)
+    error_message = "Instance type must be a valid t2 or t3 instance type."
+  }
+}
+
+variable "environment" {
+  description = "Environment name (dev, staging, prod)"
+  type        = string
+  default     = "dev"
+  
+  validation {
+    condition     = contains(["dev", "staging", "prod"], var.environment)
+    error_message = "Environment must be dev, staging, or prod."
+  }
+}
+
+variable "project_name" {
+  description = "Name of the project"
+  type        = string
+  default     = "terraform-test"
+  
+  validation {
+    condition     = can(regex("^[a-z0-9-]+$", var.project_name))
+    error_message = "Project name must contain only lowercase letters, numbers, and hyphens."
+  }
+}
+
+variable "enable_monitoring" {
+  description = "Enable CloudWatch monitoring"
+  type        = bool
+  default     = false
+}
+
+variable "allowed_cidr_blocks" {
+  description = "List of CIDR blocks allowed to access the application"
+  type        = list(string)
+  default     = ["0.0.0.0/0"]
+}
+
+variable "tags" {
+  description = "Additional tags to apply to resources"
+  type        = map(string)
+  default     = {}
+}

projects/ui/serena-new/test/resources/repos/typescript/test_repo/.serena/project.yml

@@ -0,0 +1,7 @@
+excluded_tools: []
+ignore_all_files_in_gitignore: true
+ignored_paths: []
+initial_prompt: ''
+language: typescript
+project_name: test_repo
+read_only: false

projects/ui/serena-new/test/resources/repos/typescript/test_repo/index.ts

@@ -0,0 +1,16 @@
+export class DemoClass {
+    value: number;
+    constructor(value: number) {
+        this.value = value;
+    }
+    printValue() {
+        console.log(this.value);
+    }
+}
+
+export function helperFunction() {
+    const demo = new DemoClass(42);
+    demo.printValue();
+}
+
+helperFunction();

projects/ui/serena-new/test/resources/repos/typescript/test_repo/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "module": "commonjs",
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": ["**/*.ts"]
+}

projects/ui/serena-new/test/resources/repos/typescript/test_repo/use_helper.ts

@@ -0,0 +1,8 @@
+import {helperFunction} from "./index";
+
+
+export function useHelper() {
+    helperFunction();
+}
+
+useHelper();

projects/ui/serena-new/test/resources/repos/zig/test_repo/.gitignore

@@ -0,0 +1,5 @@
+zig-cache/
+zig-out/
+.zig-cache/
+build/
+dist/

projects/ui/serena-new/test/resources/repos/zig/test_repo/build.zig

@@ -0,0 +1,31 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const exe = b.addExecutable(.{
+        .name = "test_repo",
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    b.installArtifact(exe);
+
+    const run_cmd = b.addRunArtifact(exe);
+    run_cmd.step.dependOn(b.getInstallStep());
+
+    const run_step = b.step("run", "Run the app");
+    run_step.dependOn(&run_cmd.step);
+
+    const lib_tests = b.addTest(.{
+        .root_source_file = b.path("src/calculator.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const run_lib_tests = b.addRunArtifact(lib_tests);
+    const test_step = b.step("test", "Run unit tests");
+    test_step.dependOn(&run_lib_tests.step);
+}

projects/ui/serena-new/test/resources/repos/zig/test_repo/src/calculator.zig

@@ -0,0 +1,66 @@
+const std = @import("std");
+
+pub const CalculatorError = error{
+    DivisionByZero,
+    Overflow,
+};
+
+pub const Calculator = struct {
+    const Self = @This();
+
+    pub fn init() Self {
+        return .{};
+    }
+
+    pub fn add(self: Self, a: i32, b: i32) i32 {
+        _ = self;
+        return a + b;
+    }
+
+    pub fn subtract(self: Self, a: i32, b: i32) i32 {
+        _ = self;
+        return a - b;
+    }
+
+    pub fn multiply(self: Self, a: i32, b: i32) i32 {
+        _ = self;
+        return a * b;
+    }
+
+    pub fn divide(self: Self, a: i32, b: i32) !f64 {
+        _ = self;
+        if (b == 0) {
+            return CalculatorError.DivisionByZero;
+        }
+        return @as(f64, @floatFromInt(a)) / @as(f64, @floatFromInt(b));
+    }
+
+    pub fn power(self: Self, base: i32, exponent: u32) i64 {
+        _ = self;
+        return std.math.pow(i64, base, exponent);
+    }
+};
+
+test "Calculator add" {
+    const calc = Calculator.init();
+    try std.testing.expectEqual(@as(i32, 7), calc.add(3, 4));
+    try std.testing.expectEqual(@as(i32, 0), calc.add(-5, 5));
+}
+
+test "Calculator subtract" {
+    const calc = Calculator.init();
+    try std.testing.expectEqual(@as(i32, -1), calc.subtract(3, 4));
+    try std.testing.expectEqual(@as(i32, 10), calc.subtract(15, 5));
+}
+
+test "Calculator multiply" {
+    const calc = Calculator.init();
+    try std.testing.expectEqual(@as(i32, 12), calc.multiply(3, 4));
+    try std.testing.expectEqual(@as(i32, -25), calc.multiply(-5, 5));
+}
+
+test "Calculator divide" {
+    const calc = Calculator.init();
+    try std.testing.expectEqual(@as(f64, 2.0), try calc.divide(10, 5));
+    try std.testing.expectError(CalculatorError.DivisionByZero, calc.divide(10, 0));
+}

projects/ui/serena-new/test/resources/repos/zig/test_repo/src/main.zig

@@ -0,0 +1,32 @@
+const std = @import("std");
+const calculator = @import("calculator.zig");
+const math_utils = @import("math_utils.zig");
+
+pub fn main() !void {
+    const stdout = std.io.getStdOut().writer();
+
+    const calc = calculator.Calculator.init();
+    
+    const sum = calc.add(10, 5);
+    const diff = calc.subtract(10, 5);
+    const prod = calc.multiply(10, 5);
+    const quot = calc.divide(10, 5) catch |err| {
+        try stdout.print("Division error: {}\n", .{err});
+        return;
+    };
+
+    try stdout.print("10 + 5 = {}\n", .{sum});
+    try stdout.print("10 - 5 = {}\n", .{diff});
+    try stdout.print("10 * 5 = {}\n", .{prod});
+    try stdout.print("10 / 5 = {}\n", .{quot});
+
+    const factorial_result = math_utils.factorial(5);
+    try stdout.print("5! = {}\n", .{factorial_result});
+
+    const is_prime = math_utils.isPrime(17);
+    try stdout.print("Is 17 prime? {}\n", .{is_prime});
+}
+
+pub fn greeting(name: []const u8) []const u8 {
+    return std.fmt.allocPrint(std.heap.page_allocator, "Hello, {s}!", .{name}) catch "Hello!";
+}

projects/ui/serena-new/test/resources/repos/zig/test_repo/src/math_utils.zig

@@ -0,0 +1,65 @@
+const std = @import("std");
+
+pub fn factorial(n: u32) u64 {
+    if (n == 0 or n == 1) {
+        return 1;
+    }
+    var result: u64 = 1;
+    var i: u32 = 2;
+    while (i <= n) : (i += 1) {
+        result *= i;
+    }
+    return result;
+}
+
+pub fn isPrime(n: u32) bool {
+    if (n <= 1) return false;
+    if (n <= 3) return true;
+    if (n % 2 == 0 or n % 3 == 0) return false;
+    
+    var i: u32 = 5;
+    while (i * i <= n) : (i += 6) {
+        if (n % i == 0 or n % (i + 2) == 0) {
+            return false;
+        }
+    }
+    return true;
+}
+
+pub fn gcd(a: u32, b: u32) u32 {
+    var x = a;
+    var y = b;
+    while (y != 0) {
+        const temp = y;
+        y = x % y;
+        x = temp;
+    }
+    return x;
+}
+
+pub fn lcm(a: u32, b: u32) u32 {
+    return (a * b) / gcd(a, b);
+}
+
+test "factorial" {
+    try std.testing.expectEqual(@as(u64, 1), factorial(0));
+    try std.testing.expectEqual(@as(u64, 1), factorial(1));
+    try std.testing.expectEqual(@as(u64, 120), factorial(5));
+    try std.testing.expectEqual(@as(u64, 3628800), factorial(10));
+}
+
+test "isPrime" {
+    try std.testing.expect(!isPrime(0));
+    try std.testing.expect(!isPrime(1));
+    try std.testing.expect(isPrime(2));
+    try std.testing.expect(isPrime(3));
+    try std.testing.expect(!isPrime(4));
+    try std.testing.expect(isPrime(17));
+    try std.testing.expect(!isPrime(100));
+}
+
+test "gcd and lcm" {
+    try std.testing.expectEqual(@as(u32, 6), gcd(12, 18));
+    try std.testing.expectEqual(@as(u32, 1), gcd(17, 19));
+    try std.testing.expectEqual(@as(u32, 36), lcm(12, 18));
+}

projects/ui/serena-new/test/resources/repos/zig/test_repo/zls.json

@@ -0,0 +1,12 @@
+{
+    "enable_build_on_save": true,
+    "build_on_save_args": ["build"],
+    "enable_autofix": false,
+    "semantic_tokens": "full",
+    "enable_inlay_hints": true,
+    "inlay_hints_show_builtin": true,
+    "inlay_hints_exclude_single_argument": true,
+    "inlay_hints_show_parameter_name": true,
+    "skip_std_references": false,
+    "max_detail_length": 1048576
+}

projects/ui/serena-new/test/serena/__snapshots__/test_symbol_editing.ambr

@@ -0,0 +1,1108 @@
+# serializer version: 1
+# name: test_delete_symbol[test_case0]
+  '''
+  """
+  Test module for variable declarations and usage.
+  
+  This module tests various types of variable declarations and usages including:
+  - Module-level variables
+  - Class-level variables
+  - Instance variables
+  - Variable reassignments
+  """
+  
+  from dataclasses import dataclass, field
+  
+  # Module-level variables
+  module_var = "Initial module value"
+  
+  reassignable_module_var = 10
+  reassignable_module_var = 20  # Reassigned
+  
+  # Module-level variable with type annotation
+  typed_module_var: int = 42
+  
+  
+  # Regular class with class and instance variables
+  
+  
+  
+  # Dataclass with variables
+  @dataclass
+  class VariableDataclass:
+      """Dataclass that contains various fields."""
+  
+      # Field variables with type annotations
+      id: int
+      name: str
+      items: list[str] = field(default_factory=list)
+      metadata: dict[str, str] = field(default_factory=dict)
+      optional_value: float | None = None
+  
+      # This will be reassigned in various places
+      status: str = "pending"
+  
+  
+  # Function that uses the module variables
+  def use_module_variables():
+      """Function that uses module-level variables."""
+      result = module_var + " used in function"
+      other_result = reassignable_module_var * 2
+      return result, other_result
+  
+  
+  # Create instances and use variables
+  dataclass_instance = VariableDataclass(id=1, name="Test")
+  dataclass_instance.status = "active"  # Reassign dataclass field
+  
+  # Use variables at module level
+  module_result = module_var + " used at module level"
+  other_module_result = reassignable_module_var + 30
+  
+  # Create a second dataclass instance with different status
+  second_dataclass = VariableDataclass(id=2, name="Another Test")
+  second_dataclass.status = "completed"  # Another reassignment of status
+  
+  '''
+# ---
+# name: test_delete_symbol[test_case1]
+  '''
+  
+  
+  export function helperFunction() {
+      const demo = new DemoClass(42);
+      demo.printValue();
+  }
+  
+  helperFunction();
+  
+  '''
+# ---
+# name: test_insert_in_rel_to_symbol[test_case0-after]
+  '''
+  """
+  Test module for variable declarations and usage.
+  
+  This module tests various types of variable declarations and usages including:
+  - Module-level variables
+  - Class-level variables
+  - Instance variables
+  - Variable reassignments
+  """
+  
+  from dataclasses import dataclass, field
+  
+  # Module-level variables
+  module_var = "Initial module value"
+  
+  reassignable_module_var = 10
+  reassignable_module_var = 20  # Reassigned
+  
+  # Module-level variable with type annotation
+  typed_module_var: int = 42
+  new_module_var = "Inserted after typed_module_var"
+  
+  
+  # Regular class with class and instance variables
+  class VariableContainer:
+      """Class that contains various variables."""
+  
+      # Class-level variables
+      class_var = "Initial class value"
+  
+      reassignable_class_var = True
+      reassignable_class_var = False  # Reassigned #noqa: PIE794
+  
+      # Class-level variable with type annotation
+      typed_class_var: str = "typed value"
+  
+      def __init__(self):
+          # Instance variables
+          self.instance_var = "Initial instance value"
+          self.reassignable_instance_var = 100
+  
+          # Instance variable with type annotation
+          self.typed_instance_var: list[str] = ["item1", "item2"]
+  
+      def modify_instance_var(self):
+          # Reassign instance variable
+          self.instance_var = "Modified instance value"
+          self.reassignable_instance_var = 200  # Reassigned
+  
+      def use_module_var(self):
+          # Use module-level variables
+          result = module_var + " used in method"
+          other_result = reassignable_module_var + 5
+          return result, other_result
+  
+      def use_class_var(self):
+          # Use class-level variables
+          result = VariableContainer.class_var + " used in method"
+          other_result = VariableContainer.reassignable_class_var
+          return result, other_result
+  
+  
+  # Dataclass with variables
+  @dataclass
+  class VariableDataclass:
+      """Dataclass that contains various fields."""
+  
+      # Field variables with type annotations
+      id: int
+      name: str
+      items: list[str] = field(default_factory=list)
+      metadata: dict[str, str] = field(default_factory=dict)
+      optional_value: float | None = None
+  
+      # This will be reassigned in various places
+      status: str = "pending"
+  
+  
+  # Function that uses the module variables
+  def use_module_variables():
+      """Function that uses module-level variables."""
+      result = module_var + " used in function"
+      other_result = reassignable_module_var * 2
+      return result, other_result
+  
+  
+  # Create instances and use variables
+  dataclass_instance = VariableDataclass(id=1, name="Test")
+  dataclass_instance.status = "active"  # Reassign dataclass field
+  
+  # Use variables at module level
+  module_result = module_var + " used at module level"
+  other_module_result = reassignable_module_var + 30
+  
+  # Create a second dataclass instance with different status
+  second_dataclass = VariableDataclass(id=2, name="Another Test")
+  second_dataclass.status = "completed"  # Another reassignment of status
+  
+  '''
+# ---
+# name: test_insert_in_rel_to_symbol[test_case0-before]
+  '''
+  """
+  Test module for variable declarations and usage.
+  
+  This module tests various types of variable declarations and usages including:
+  - Module-level variables
+  - Class-level variables
+  - Instance variables
+  - Variable reassignments
+  """
+  
+  from dataclasses import dataclass, field
+  
+  # Module-level variables
+  module_var = "Initial module value"
+  
+  reassignable_module_var = 10
+  reassignable_module_var = 20  # Reassigned
+  
+  # Module-level variable with type annotation
+  new_module_var = "Inserted after typed_module_var"
+  typed_module_var: int = 42
+  
+  
+  # Regular class with class and instance variables
+  class VariableContainer:
+      """Class that contains various variables."""
+  
+      # Class-level variables
+      class_var = "Initial class value"
+  
+      reassignable_class_var = True
+      reassignable_class_var = False  # Reassigned #noqa: PIE794
+  
+      # Class-level variable with type annotation
+      typed_class_var: str = "typed value"
+  
+      def __init__(self):
+          # Instance variables
+          self.instance_var = "Initial instance value"
+          self.reassignable_instance_var = 100
+  
+          # Instance variable with type annotation
+          self.typed_instance_var: list[str] = ["item1", "item2"]
+  
+      def modify_instance_var(self):
+          # Reassign instance variable
+          self.instance_var = "Modified instance value"
+          self.reassignable_instance_var = 200  # Reassigned
+  
+      def use_module_var(self):
+          # Use module-level variables
+          result = module_var + " used in method"
+          other_result = reassignable_module_var + 5
+          return result, other_result
+  
+      def use_class_var(self):
+          # Use class-level variables
+          result = VariableContainer.class_var + " used in method"
+          other_result = VariableContainer.reassignable_class_var
+          return result, other_result
+  
+  
+  # Dataclass with variables
+  @dataclass
+  class VariableDataclass:
+      """Dataclass that contains various fields."""
+  
+      # Field variables with type annotations
+      id: int
+      name: str
+      items: list[str] = field(default_factory=list)
+      metadata: dict[str, str] = field(default_factory=dict)
+      optional_value: float | None = None
+  
+      # This will be reassigned in various places
+      status: str = "pending"
+  
+  
+  # Function that uses the module variables
+  def use_module_variables():
+      """Function that uses module-level variables."""
+      result = module_var + " used in function"
+      other_result = reassignable_module_var * 2
+      return result, other_result
+  
+  
+  # Create instances and use variables
+  dataclass_instance = VariableDataclass(id=1, name="Test")
+  dataclass_instance.status = "active"  # Reassign dataclass field
+  
+  # Use variables at module level
+  module_result = module_var + " used at module level"
+  other_module_result = reassignable_module_var + 30
+  
+  # Create a second dataclass instance with different status
+  second_dataclass = VariableDataclass(id=2, name="Another Test")
+  second_dataclass.status = "completed"  # Another reassignment of status
+  
+  '''
+# ---
+# name: test_insert_in_rel_to_symbol[test_case1-after]
+  '''
+  """
+  Test module for variable declarations and usage.
+  
+  This module tests various types of variable declarations and usages including:
+  - Module-level variables
+  - Class-level variables
+  - Instance variables
+  - Variable reassignments
+  """
+  
+  from dataclasses import dataclass, field
+  
+  # Module-level variables
+  module_var = "Initial module value"
+  
+  reassignable_module_var = 10
+  reassignable_module_var = 20  # Reassigned
+  
+  # Module-level variable with type annotation
+  typed_module_var: int = 42
+  
+  
+  # Regular class with class and instance variables
+  class VariableContainer:
+      """Class that contains various variables."""
+  
+      # Class-level variables
+      class_var = "Initial class value"
+  
+      reassignable_class_var = True
+      reassignable_class_var = False  # Reassigned #noqa: PIE794
+  
+      # Class-level variable with type annotation
+      typed_class_var: str = "typed value"
+  
+      def __init__(self):
+          # Instance variables
+          self.instance_var = "Initial instance value"
+          self.reassignable_instance_var = 100
+  
+          # Instance variable with type annotation
+          self.typed_instance_var: list[str] = ["item1", "item2"]
+  
+      def modify_instance_var(self):
+          # Reassign instance variable
+          self.instance_var = "Modified instance value"
+          self.reassignable_instance_var = 200  # Reassigned
+  
+      def use_module_var(self):
+          # Use module-level variables
+          result = module_var + " used in method"
+          other_result = reassignable_module_var + 5
+          return result, other_result
+  
+      def use_class_var(self):
+          # Use class-level variables
+          result = VariableContainer.class_var + " used in method"
+          other_result = VariableContainer.reassignable_class_var
+          return result, other_result
+  
+  
+  # Dataclass with variables
+  @dataclass
+  class VariableDataclass:
+      """Dataclass that contains various fields."""
+  
+      # Field variables with type annotations
+      id: int
+      name: str
+      items: list[str] = field(default_factory=list)
+      metadata: dict[str, str] = field(default_factory=dict)
+      optional_value: float | None = None
+  
+      # This will be reassigned in various places
+      status: str = "pending"
+  
+  
+  # Function that uses the module variables
+  def use_module_variables():
+      """Function that uses module-level variables."""
+      result = module_var + " used in function"
+      other_result = reassignable_module_var * 2
+      return result, other_result
+  
+  def new_inserted_function():
+      print("This is a new function inserted before another.")
+  
+  
+  # Create instances and use variables
+  dataclass_instance = VariableDataclass(id=1, name="Test")
+  dataclass_instance.status = "active"  # Reassign dataclass field
+  
+  # Use variables at module level
+  module_result = module_var + " used at module level"
+  other_module_result = reassignable_module_var + 30
+  
+  # Create a second dataclass instance with different status
+  second_dataclass = VariableDataclass(id=2, name="Another Test")
+  second_dataclass.status = "completed"  # Another reassignment of status
+  
+  '''
+# ---
+# name: test_insert_in_rel_to_symbol[test_case1-before]
+  '''
+  """
+  Test module for variable declarations and usage.
+  
+  This module tests various types of variable declarations and usages including:
+  - Module-level variables
+  - Class-level variables
+  - Instance variables
+  - Variable reassignments
+  """
+  
+  from dataclasses import dataclass, field
+  
+  # Module-level variables
+  module_var = "Initial module value"
+  
+  reassignable_module_var = 10
+  reassignable_module_var = 20  # Reassigned
+  
+  # Module-level variable with type annotation
+  typed_module_var: int = 42
+  
+  
+  # Regular class with class and instance variables
+  class VariableContainer:
+      """Class that contains various variables."""
+  
+      # Class-level variables
+      class_var = "Initial class value"
+  
+      reassignable_class_var = True
+      reassignable_class_var = False  # Reassigned #noqa: PIE794
+  
+      # Class-level variable with type annotation
+      typed_class_var: str = "typed value"
+  
+      def __init__(self):
+          # Instance variables
+          self.instance_var = "Initial instance value"
+          self.reassignable_instance_var = 100
+  
+          # Instance variable with type annotation
+          self.typed_instance_var: list[str] = ["item1", "item2"]
+  
+      def modify_instance_var(self):
+          # Reassign instance variable
+          self.instance_var = "Modified instance value"
+          self.reassignable_instance_var = 200  # Reassigned
+  
+      def use_module_var(self):
+          # Use module-level variables
+          result = module_var + " used in method"
+          other_result = reassignable_module_var + 5
+          return result, other_result
+  
+      def use_class_var(self):
+          # Use class-level variables
+          result = VariableContainer.class_var + " used in method"
+          other_result = VariableContainer.reassignable_class_var
+          return result, other_result
+  
+  
+  # Dataclass with variables
+  @dataclass
+  class VariableDataclass:
+      """Dataclass that contains various fields."""
+  
+      # Field variables with type annotations
+      id: int
+      name: str
+      items: list[str] = field(default_factory=list)
+      metadata: dict[str, str] = field(default_factory=dict)
+      optional_value: float | None = None
+  
+      # This will be reassigned in various places
+      status: str = "pending"
+  
+  
+  # Function that uses the module variables
+  def new_inserted_function():
+      print("This is a new function inserted before another.")
+  
+  def use_module_variables():
+      """Function that uses module-level variables."""
+      result = module_var + " used in function"
+      other_result = reassignable_module_var * 2
+      return result, other_result
+  
+  
+  # Create instances and use variables
+  dataclass_instance = VariableDataclass(id=1, name="Test")
+  dataclass_instance.status = "active"  # Reassign dataclass field
+  
+  # Use variables at module level
+  module_result = module_var + " used at module level"
+  other_module_result = reassignable_module_var + 30
+  
+  # Create a second dataclass instance with different status
+  second_dataclass = VariableDataclass(id=2, name="Another Test")
+  second_dataclass.status = "completed"  # Another reassignment of status
+  
+  '''
+# ---
+# name: test_insert_in_rel_to_symbol[test_case2-after]
+  '''
+  export class DemoClass {
+      value: number;
+      constructor(value: number) {
+          this.value = value;
+      }
+      printValue() {
+          console.log(this.value);
+      }
+  }
+  
+  function newFunctionAfterClass(): void {
+      console.log("This function is after DemoClass.");
+  }
+  
+  export function helperFunction() {
+      const demo = new DemoClass(42);
+      demo.printValue();
+  }
+  
+  helperFunction();
+  
+  '''
+# ---
+# name: test_insert_in_rel_to_symbol[test_case2-before]
+  '''
+  function newFunctionAfterClass(): void {
+      console.log("This function is after DemoClass.");
+  }
+  
+  export class DemoClass {
+      value: number;
+      constructor(value: number) {
+          this.value = value;
+      }
+      printValue() {
+          console.log(this.value);
+      }
+  }
+  
+  export function helperFunction() {
+      const demo = new DemoClass(42);
+      demo.printValue();
+  }
+  
+  helperFunction();
+  
+  '''
+# ---
+# name: test_insert_in_rel_to_symbol[test_case3-after]
+  '''
+  export class DemoClass {
+      value: number;
+      constructor(value: number) {
+          this.value = value;
+      }
+      printValue() {
+          console.log(this.value);
+      }
+  }
+  
+  export function helperFunction() {
+      const demo = new DemoClass(42);
+      demo.printValue();
+  }
+  
+  function newInsertedFunction(): void {
+      console.log("This is a new function inserted before another.");
+  }
+  
+  helperFunction();
+  
+  '''
+# ---
+# name: test_insert_in_rel_to_symbol[test_case3-before]
+  '''
+  export class DemoClass {
+      value: number;
+      constructor(value: number) {
+          this.value = value;
+      }
+      printValue() {
+          console.log(this.value);
+      }
+  }
+  
+  function newInsertedFunction(): void {
+      console.log("This is a new function inserted before another.");
+  }
+  
+  export function helperFunction() {
+      const demo = new DemoClass(42);
+      demo.printValue();
+  }
+  
+  helperFunction();
+  
+  '''
+# ---
+# name: test_insert_python_class_after
+  '''
+  """
+  Test module for variable declarations and usage.
+  
+  This module tests various types of variable declarations and usages including:
+  - Module-level variables
+  - Class-level variables
+  - Instance variables
+  - Variable reassignments
+  """
+  
+  from dataclasses import dataclass, field
+  
+  # Module-level variables
+  module_var = "Initial module value"
+  
+  reassignable_module_var = 10
+  reassignable_module_var = 20  # Reassigned
+  
+  # Module-level variable with type annotation
+  typed_module_var: int = 42
+  
+  
+  # Regular class with class and instance variables
+  class VariableContainer:
+      """Class that contains various variables."""
+  
+      # Class-level variables
+      class_var = "Initial class value"
+  
+      reassignable_class_var = True
+      reassignable_class_var = False  # Reassigned #noqa: PIE794
+  
+      # Class-level variable with type annotation
+      typed_class_var: str = "typed value"
+  
+      def __init__(self):
+          # Instance variables
+          self.instance_var = "Initial instance value"
+          self.reassignable_instance_var = 100
+  
+          # Instance variable with type annotation
+          self.typed_instance_var: list[str] = ["item1", "item2"]
+  
+      def modify_instance_var(self):
+          # Reassign instance variable
+          self.instance_var = "Modified instance value"
+          self.reassignable_instance_var = 200  # Reassigned
+  
+      def use_module_var(self):
+          # Use module-level variables
+          result = module_var + " used in method"
+          other_result = reassignable_module_var + 5
+          return result, other_result
+  
+      def use_class_var(self):
+          # Use class-level variables
+          result = VariableContainer.class_var + " used in method"
+          other_result = VariableContainer.reassignable_class_var
+          return result, other_result
+  
+  
+  # Dataclass with variables
+  @dataclass
+  class VariableDataclass:
+      """Dataclass that contains various fields."""
+  
+      # Field variables with type annotations
+      id: int
+      name: str
+      items: list[str] = field(default_factory=list)
+      metadata: dict[str, str] = field(default_factory=dict)
+      optional_value: float | None = None
+  
+      # This will be reassigned in various places
+      status: str = "pending"
+  
+  
+  class NewInsertedClass:
+      pass
+  
+  
+  # Function that uses the module variables
+  def use_module_variables():
+      """Function that uses module-level variables."""
+      result = module_var + " used in function"
+      other_result = reassignable_module_var * 2
+      return result, other_result
+  
+  
+  # Create instances and use variables
+  dataclass_instance = VariableDataclass(id=1, name="Test")
+  dataclass_instance.status = "active"  # Reassign dataclass field
+  
+  # Use variables at module level
+  module_result = module_var + " used at module level"
+  other_module_result = reassignable_module_var + 30
+  
+  # Create a second dataclass instance with different status
+  second_dataclass = VariableDataclass(id=2, name="Another Test")
+  second_dataclass.status = "completed"  # Another reassignment of status
+  
+  '''
+# ---
+# name: test_insert_python_class_before
+  '''
+  """
+  Test module for variable declarations and usage.
+  
+  This module tests various types of variable declarations and usages including:
+  - Module-level variables
+  - Class-level variables
+  - Instance variables
+  - Variable reassignments
+  """
+  
+  from dataclasses import dataclass, field
+  
+  # Module-level variables
+  module_var = "Initial module value"
+  
+  reassignable_module_var = 10
+  reassignable_module_var = 20  # Reassigned
+  
+  # Module-level variable with type annotation
+  typed_module_var: int = 42
+  
+  
+  # Regular class with class and instance variables
+  class VariableContainer:
+      """Class that contains various variables."""
+  
+      # Class-level variables
+      class_var = "Initial class value"
+  
+      reassignable_class_var = True
+      reassignable_class_var = False  # Reassigned #noqa: PIE794
+  
+      # Class-level variable with type annotation
+      typed_class_var: str = "typed value"
+  
+      def __init__(self):
+          # Instance variables
+          self.instance_var = "Initial instance value"
+          self.reassignable_instance_var = 100
+  
+          # Instance variable with type annotation
+          self.typed_instance_var: list[str] = ["item1", "item2"]
+  
+      def modify_instance_var(self):
+          # Reassign instance variable
+          self.instance_var = "Modified instance value"
+          self.reassignable_instance_var = 200  # Reassigned
+  
+      def use_module_var(self):
+          # Use module-level variables
+          result = module_var + " used in method"
+          other_result = reassignable_module_var + 5
+          return result, other_result
+  
+      def use_class_var(self):
+          # Use class-level variables
+          result = VariableContainer.class_var + " used in method"
+          other_result = VariableContainer.reassignable_class_var
+          return result, other_result
+  
+  
+  # Dataclass with variables
+  class NewInsertedClass:
+      pass
+  
+  
+  @dataclass
+  class VariableDataclass:
+      """Dataclass that contains various fields."""
+  
+      # Field variables with type annotations
+      id: int
+      name: str
+      items: list[str] = field(default_factory=list)
+      metadata: dict[str, str] = field(default_factory=dict)
+      optional_value: float | None = None
+  
+      # This will be reassigned in various places
+      status: str = "pending"
+  
+  
+  # Function that uses the module variables
+  def use_module_variables():
+      """Function that uses module-level variables."""
+      result = module_var + " used in function"
+      other_result = reassignable_module_var * 2
+      return result, other_result
+  
+  
+  # Create instances and use variables
+  dataclass_instance = VariableDataclass(id=1, name="Test")
+  dataclass_instance.status = "active"  # Reassign dataclass field
+  
+  # Use variables at module level
+  module_result = module_var + " used at module level"
+  other_module_result = reassignable_module_var + 30
+  
+  # Create a second dataclass instance with different status
+  second_dataclass = VariableDataclass(id=2, name="Another Test")
+  second_dataclass.status = "completed"  # Another reassignment of status
+  
+  '''
+# ---
+# name: test_nix_symbol_replacement_no_double_semicolon
+  '''
+  # default.nix - Traditional Nix expression for backwards compatibility
+  { pkgs ? import <nixpkgs> { } }:
+  
+  let
+    # Import library functions
+    lib = pkgs.lib;
+    stdenv = pkgs.stdenv;
+  
+    # Import our custom utilities
+    utils = import ./lib/utils.nix { inherit lib; };
+  
+    # Custom function to create a greeting
+    makeGreeting = name: "Hello, ${name}!";
+  
+    # List manipulation functions (using imported utils)
+    listUtils = {
+      double = list: map (x: x * 2) list;
+      sum = list: lib.foldl' (acc: x: acc + x) 0 list;
+      average = list:
+        if list == [ ]
+        then 0
+        else (listUtils.sum list) / (builtins.length list);
+      # Use function from imported utils
+      unique = utils.lists.unique;
+    };
+  
+    # String utilities
+    stringUtils = rec {
+      capitalize = str:
+        let
+          first = lib.substring 0 1 str;
+          rest = lib.substring 1 (-1) str;
+        in
+        (lib.toUpper first) + rest;
+  
+      repeat = n: str: lib.concatStrings (lib.genList (_: str) n);
+  
+      padLeft = width: char: str:
+        let
+          len = lib.stringLength str;
+          padding = if len >= width then 0 else width - len;
+        in
+        (repeat padding char) + str;
+    };
+  
+    # Package builder helper
+    buildSimplePackage = { name, version, script }:
+      stdenv.mkDerivation {
+        pname = name;
+        inherit version;
+  
+        phases = [ "installPhase" ];
+  
+        installPhase = ''
+          mkdir -p $out/bin
+          cat > $out/bin/${name} << EOF
+          #!/usr/bin/env bash
+          ${script}
+          EOF
+          chmod +x $out/bin/${name}
+        '';
+      };
+  
+  in
+  rec {
+    # Export utilities
+    inherit listUtils stringUtils makeGreeting;
+  
+    # Export imported utilities directly
+    inherit (utils) math strings;
+  
+    # Example packages
+    hello = buildSimplePackage {
+      name = "hello";
+      version = "1.0";
+      script = ''
+        echo "${makeGreeting "World"}"
+      '';
+    };
+  
+    calculator = buildSimplePackage {
+      name = "calculator";
+      version = "0.1";
+      script = ''
+        if [ $# -ne 3 ]; then
+          echo "Usage: calculator <num1> <op> <num2>"
+          exit 1
+        fi
+        
+        case $2 in
+          +) echo $(($1 + $3)) ;;
+          -) echo $(($1 - $3)) ;;
+          x) echo $(($1 * $3)) ;;
+          /) echo $(($1 / $3)) ;;
+          *) echo "Unknown operator: $2" ;;
+        esac
+      '';
+    };
+  
+    # Environment with multiple packages
+    devEnv = pkgs.buildEnv {
+      name = "dev-environment";
+      paths = with pkgs; [
+        git
+        vim
+        bash
+        hello
+        calculator
+      ];
+    };
+  
+    # Shell derivation
+    shell = pkgs.mkShell {
+      buildInputs = with pkgs; [
+        bash
+        coreutils
+        findutils
+        gnugrep
+        gnused
+      ];
+  
+      shellHook = ''
+        echo "Entering Nix shell environment"
+        echo "Available custom functions: makeGreeting, listUtils, stringUtils"
+      '';
+    };
+  
+    # Configuration example
+    config = {
+      system = {
+        stateVersion = "23.11";
+        enable = true;
+      };
+  
+      services = {
+        nginx = {
+          enable = false;
+          virtualHosts = {
+            "example.com" = {
+              root = "/var/www/example";
+              locations."/" = {
+                index = "index.html";
+              };
+            };
+          };
+        };
+      };
+  
+      users = {
+        c = 3;
+      };
+    };
+  
+    # Recursive attribute set example
+    tree = {
+      root = {
+        value = 1;
+        left = {
+          value = 2;
+          left = { value = 4; };
+          right = { value = 5; };
+        };
+        right = {
+          value = 3;
+          left = { value = 6; };
+          right = { value = 7; };
+        };
+      };
+  
+      # Tree traversal function
+      traverse = node:
+        if node ? left && node ? right
+        then [ node.value ] ++ (tree.traverse node.left) ++ (tree.traverse node.right)
+        else if node ? value
+        then [ node.value ]
+        else [ ];
+    };
+  }
+  
+  '''
+# ---
+# name: test_replace_body[test_case0]
+  '''
+  """
+  Test module for variable declarations and usage.
+  
+  This module tests various types of variable declarations and usages including:
+  - Module-level variables
+  - Class-level variables
+  - Instance variables
+  - Variable reassignments
+  """
+  
+  from dataclasses import dataclass, field
+  
+  # Module-level variables
+  module_var = "Initial module value"
+  
+  reassignable_module_var = 10
+  reassignable_module_var = 20  # Reassigned
+  
+  # Module-level variable with type annotation
+  typed_module_var: int = 42
+  
+  
+  # Regular class with class and instance variables
+  class VariableContainer:
+      """Class that contains various variables."""
+  
+      # Class-level variables
+      class_var = "Initial class value"
+  
+      reassignable_class_var = True
+      reassignable_class_var = False  # Reassigned #noqa: PIE794
+  
+      # Class-level variable with type annotation
+      typed_class_var: str = "typed value"
+  
+      def __init__(self):
+          # Instance variables
+          self.instance_var = "Initial instance value"
+          self.reassignable_instance_var = 100
+  
+          # Instance variable with type annotation
+          self.typed_instance_var: list[str] = ["item1", "item2"]
+  
+      def modify_instance_var(self):
+          # This body has been replaced
+          self.instance_var = "Replaced!"
+          self.reassignable_instance_var = 999  # Reassigned
+  
+      def use_module_var(self):
+          # Use module-level variables
+          result = module_var + " used in method"
+          other_result = reassignable_module_var + 5
+          return result, other_result
+  
+      def use_class_var(self):
+          # Use class-level variables
+          result = VariableContainer.class_var + " used in method"
+          other_result = VariableContainer.reassignable_class_var
+          return result, other_result
+  
+  
+  # Dataclass with variables
+  @dataclass
+  class VariableDataclass:
+      """Dataclass that contains various fields."""
+  
+      # Field variables with type annotations
+      id: int
+      name: str
+      items: list[str] = field(default_factory=list)
+      metadata: dict[str, str] = field(default_factory=dict)
+      optional_value: float | None = None
+  
+      # This will be reassigned in various places
+      status: str = "pending"
+  
+  
+  # Function that uses the module variables
+  def use_module_variables():
+      """Function that uses module-level variables."""
+      result = module_var + " used in function"
+      other_result = reassignable_module_var * 2
+      return result, other_result
+  
+  
+  # Create instances and use variables
+  dataclass_instance = VariableDataclass(id=1, name="Test")
+  dataclass_instance.status = "active"  # Reassign dataclass field
+  
+  # Use variables at module level
+  module_result = module_var + " used at module level"
+  other_module_result = reassignable_module_var + 30
+  
+  # Create a second dataclass instance with different status
+  second_dataclass = VariableDataclass(id=2, name="Another Test")
+  second_dataclass.status = "completed"  # Another reassignment of status
+  
+  '''
+# ---
+# name: test_replace_body[test_case1]
+  '''
+  export class DemoClass {
+      value: number;
+      constructor(value: number) {
+          this.value = value;
+      }
+      function printValue() {
+          // This body has been replaced
+          console.warn("New value: " + this.value);
+      }
+  }
+  
+  export function helperFunction() {
+      const demo = new DemoClass(42);
+      demo.printValue();
+  }
+  
+  helperFunction();
+  
+  '''
+# ---

projects/ui/serena-new/test/serena/config/__init__.py

@@ -0,0 +1 @@
+# Empty init file for test package