// Test data file for goto_def_test.v
module main

import v.tests.vls.sample_mod1 as s

struct LocalStruct {
	value int
}

fn (ls LocalStruct) my_method() string {
	return 'method'
}

fn test_local_struct() {
 	mut obj := LocalStruct{value: 42}

	msg := obj.my_method()
	println(msg)

	another := LocalStruct{}
	println(another.value)

	yet_another := obj
	println(yet_another)

	val := obj.value
	println(val)

	result := obj.my_method()
	println(result)

	ret_type := obj.my_method()
	println(ret_type)
}

struct DeepStruct {
	LocalStruct
	st struct {
		sstt struct {
			l2 int
		}
		l1 int
	}
	l0 int
}

fn test_deep_struct() {
  deep := DeepStruct{}
	nested_val := deep.st.sstt.l2
	println(nested_val)

	embedded_val := deep.LocalStruct
	println(embedded_val)

	deep_2 := DeepStruct {
	  st: struct {
			sstt: struct {
			  l2: deep.st.sstt.l2
			}
			l1: deep.st.l1
		}
	}
}

enum LocalEnum {
	first
	second
	third
}

fn test_local_enum() {
  e1 := LocalEnum.first

	match e1 {
		.second { println('second') }
		else {}
	}
}

type LocalAlias = string

fn test_local_alias() {
  casted := LocalAlias('test')
}

type LocalSum = int | string

struct TypeA {
	a int
}

struct TypeB {
	b string
}

type UserSum = TypeA | TypeB

fn test_local_sum() {
	sum_val := LocalSum(42)
	println(sum_val)

	user_sum := UserSum(TypeA{a: 10})
	println(user_sum)
}

enum Method {
	completion
	signature_help
	definition
}

fn test_match_enum() {
	method := Method.completion
	line_info := match method {
		.completion {
			'completion_info'
		}
		.signature_help {
			'signature_info'
		}
		.definition {
			'definition_info'
		}
	}
	println(line_info)
}

fn test_imported_enum() {
	imported_e := s.PublicEnum1.a
	println(imported_e)
}

struct OpStruct {
	val int
}

fn (a OpStruct) + (b OpStruct) OpStruct {
	return OpStruct{val: a.val + b.val}
}

fn takes_struct(param OpStruct) string {
	return param.str()
}

struct ArrayElemStruct {
	value int
}

struct ContainerStruct {
	items []ArrayElemStruct
	fixed_items [5]ArrayElemStruct
}