Go Race Detector Simulation

This challenge asks you to simulate a simplified race detector in Go. Race conditions occur when multiple goroutines access and modify shared data concurrently, leading to unpredictable and potentially incorrect program behavior. Your task is to build a program that detects potential race conditions on shared variables within a given Go program's execution.

Problem Description

You are to create a program that analyzes a simplified Go program's execution and identifies potential race conditions. The input will be a string representing a Go program's code snippet. This code snippet will contain a few goroutines and shared variables. Your program should simulate the execution of this code, tracking accesses to shared variables by each goroutine. If multiple goroutines access (read or write) the same shared variable concurrently (i.e., at the same logical time), your program should report a race condition.

Key Requirements:

• Shared Variable Tracking: Your program must identify shared variables (variables accessed by multiple goroutines).
• Concurrency Detection: It must detect concurrent access (read or write) to shared variables by different goroutines.
• Race Condition Reporting: Upon detecting a race condition, your program should output a clear message indicating the shared variable and the goroutines involved.
• Simplified Execution: You don't need to fully execute the Go code. Instead, focus on simulating the access patterns to shared variables. Assume a simplified execution model where each line of code within a goroutine is executed sequentially.
• No actual Go compilation or execution: The input is a string representing the code, not a compiled executable.

Expected Behavior:

The program should take a string representing the Go code snippet as input. It should then analyze the code, identify shared variables, and detect any concurrent access to those variables. If a race condition is detected, the program should print a message to the console in the format: "Race condition detected: Variable <variable_name> accessed concurrently by Goroutine <goroutine_id> and Goroutine <goroutine_id>". If no race conditions are detected, the program should print "No race conditions detected."

Edge Cases to Consider:

• Variables declared within a goroutine are not considered shared unless accessed by another goroutine.
• Multiple writes to the same variable by the same goroutine are not considered a race condition.
• Reads by multiple goroutines on the same variable are considered a race condition.
• Writes by multiple goroutines on the same variable are considered a race condition.
• The input code snippet may contain multiple goroutines.
• The input code snippet may not contain any race conditions.

Examples

Example 1:

Input:
```go
package main

import "fmt"

var counter int

func main() {
	go func() {
		counter++
		fmt.Println("Goroutine 1 incremented counter")
	}()

	go func() {
		counter--
		fmt.Println("Goroutine 2 decremented counter")
	}()

	// Wait for goroutines to finish (simplified)
	fmt.Println("Main goroutine finished")
}

Output:
Race condition detected: Variable counter accessed concurrently by Goroutine 1 and Goroutine 2

Explanation: Both Goroutine 1 and Goroutine 2 access the shared variable counter concurrently.

Example 2:

Input:
```go
package main

import "fmt"

var x int = 10

func main() {
	go func() {
		x = 20
		fmt.Println("Goroutine 1 modified x")
	}()

	go func() {
		fmt.Println("Goroutine 2 read x:", x)
	}()

	// Wait for goroutines to finish (simplified)
	fmt.Println("Main goroutine finished")
}

Output:
Race condition detected: Variable x accessed concurrently by Goroutine 1 and Goroutine 2

Explanation: Goroutine 1 writes to x, and Goroutine 2 reads x concurrently.

Example 3:

Input:
```go
package main

import "fmt"

var y int = 5

func main() {
	go func() {
		y = 15
		fmt.Println("Goroutine 1 modified y")
	}()

	fmt.Println("Main goroutine read y:", y)
}

Output:
No race conditions detected.

Explanation: Only one goroutine (Goroutine 1) modifies y, and the main goroutine reads it. There's no concurrent access.

Constraints

• The input Go code snippet will be a string.
• The code snippet will be relatively simple, focusing on shared variable access.
• The number of goroutines will be limited to 2 or 3.
• The number of shared variables will be limited to 3 or 4.
• The code snippet will not contain complex control flow structures (e.g., loops, nested functions). Focus on sequential execution within each goroutine.
• The program should complete within a reasonable time (e.g., under 1 second) for the given input size.

Notes

• This is a simplified simulation. A real race detector would involve more sophisticated analysis techniques.
• You can use string parsing and regular expressions to extract information from the Go code snippet.
• Consider using a data structure (e.g., a map) to track shared variables and the goroutines that access them.
• The "logical time" of execution can be approximated by the order of lines in the code snippet.
• Focus on detecting potential race conditions. False positives are acceptable in this simplified scenario. False negatives are not.
• Assume that fmt.Println calls do not introduce race conditions. They are simply for demonstration purposes in the input code.