builtin: prepare for error interfaces (#9043)

vlib/builtin/option.v

@@ -3,74 +3,66 @@
 // that can be found in the LICENSE file.
 module builtin
 
-struct OptionBase {
-	ok      bool
-	is_none bool
-	error   string
-	ecode   int
-	// Data is trailing after ecode
-	// and is not included in here but in the
-	// derived Option_xxx types
+// IError holds information about an error instance
+pub interface IError {
+	msg  string
+	code int
 }
 
-// `fn foo() ?Foo { return foo }` => `fn foo() ?Foo { return opt_ok(foo); }`
-fn opt_ok2(data voidptr, mut option OptionBase, size int) {
+// Error is the default implementation of IError, that is returned by e.g. `error()`
+pub struct Error {
+pub:
+	msg  string
+	code int
+}
+
+pub struct Option3 {
+	state byte
+	err   IError
+}
+
+[inline]
+fn (e IError) str() string {
+	return e.msg
+}
+
+fn opt_ok3(data voidptr, mut option Option3, size int) {
 	unsafe {
-		*option = OptionBase{
-			ok: true
-		}
-		// use ecode to get the end of OptionBase and then memcpy into it
-		C.memcpy(byteptr(&option.ecode) + sizeof(int), data, size)
+		*option = Option3{}
+		// use err to get the end of Option3 and then memcpy into it
+		C.memcpy(byteptr(&option.err) + sizeof(IError), data, size)
 	}
 }
 
-// Option is the old option type used for bootstrapping
-struct Option {
-	ok      bool
-	is_none bool
-	error   string
-	ecode   int
-}
-
-// str returns the string representation of the Option.
-pub fn (o Option) str() string {
-	if o.ok && !o.is_none {
+pub fn (o Option3) str() string {
+	if o.state == 0 {
 		return 'Option{ ok }'
 	}
-	if o.is_none {
+	if o.state == 1 {
 		return 'Option{ none }'
 	}
-	return 'Option{ error: "$o.error" }'
+	return 'Option{ err: "$o.err" }'
 }
 
-// opt_none is used internally when returning `none`.
-fn opt_none() Option {
-	return Option{
-		ok: false
-		is_none: true
+[inline]
+pub fn error3(message string) IError {
+	return &Error{
+		msg: message
 	}
 }
 
-// error returns an optional containing the error given in `message`.
-// `if ouch { return error('an error occurred') }`
-pub fn error(message string) Option {
-	return Option{
-		ok: false
-		is_none: false
-		error: message
+pub fn error_with_code3(message string, code int) IError {
+	return &Error {
+		msg: message
+		code: code
 	}
 }
 
-// error_with_code returns an optional containing both error `message` and error `code`.
-// `if ouch { return error_with_code('an error occurred',1) }`
-pub fn error_with_code(message string, code int) Option {
-	return Option{
-		ok: false
-		is_none: false
-		error: message
-		ecode: code
-	}
-}
+////////////////////////////////////////
+
+// these are just here temporarily to avoid breaking the compiler; they will be removed soon
+pub fn error(a string) Option2 { return {} }
+pub fn error_with_code(a string, b int) Option2 { return {} }
 
 // Option2 is the base of V's new internal optional return system.
 struct Option2 {
@@ -81,13 +73,6 @@ struct Option2 {
 	// derived Option2_xxx types
 }
 
-// Error holds information about an error instance
-pub struct Error {
-pub:
-	msg  string
-	code int
-}
-
 [inline]
 fn (e Error) str() string {
 	// TODO: this should probably have a better str method,
@@ -104,15 +89,14 @@ fn opt_ok(data voidptr, mut option Option2, size int) {
 	}
 }
 
-// /*
 pub fn (o Option2) str() string {
 	if o.state == 0 {
-		return 'Option2{ ok }'
+		return 'Option{ ok }'
 	}
 	if o.state == 1 {
-		return 'Option2{ none }'
+		return 'Option{ none }'
 	}
-	return 'Option2{ err: "$o.err" }'
+	return 'Option{ err: "$o.err" }'
 }
 
 // error returns an optional containing the error given in `message`.
@@ -137,4 +121,3 @@ pub fn error_with_code2(message string, code int) Option2 {
 		}
 	}
 }
-// */