Merge pull request #848 from goby-lang/refactor-builtin-method-yield

st0012 · web-flow · commit 44f3a14d0a5f · 2020-05-03T17:38:43.000+08:00
Make t.builtinMethodYield return an Object instead of a Pointer
diff --git a/vm/array.go b/vm/array.go
@@ -44,7 +44,7 @@ var builtinArrayClassMethods = []*BuiltinMethodObject{
 
 				if blockFrame != nil && !blockIsEmpty(blockFrame) {
 					for i := range elems {
-						elems[i] = t.builtinMethodYield(blockFrame, t.vm.InitIntegerObject(i)).Target
+						elems[i] = t.builtinMethodYield(blockFrame, t.vm.InitIntegerObject(i))
 					}
 				} else {
 					var elem Object
@@ -413,7 +413,7 @@ var builtinArrayInstanceMethods = []*BuiltinMethodObject{
 			for _, obj := range arr.Elements {
 				result := t.builtinMethodYield(blockFrame, obj)
 
-				if result.Target.isTruthy() {
+				if result.isTruthy() {
 					return TRUE
 				}
 			}
@@ -541,7 +541,7 @@ var builtinArrayInstanceMethods = []*BuiltinMethodObject{
 
 				for _, obj := range arr.Elements {
 					result := t.builtinMethodYield(blockFrame, obj)
-					if result.Target.isTruthy() {
+					if result.isTruthy() {
 						count++
 					}
 				}
@@ -930,12 +930,12 @@ var builtinArrayInstanceMethods = []*BuiltinMethodObject{
 			switch len(args) {
 			case 0:
 				for _, obj := range a.Elements {
-					hash[obj.ToString()] = t.builtinMethodYield(blockFrame, obj).Target
+					hash[obj.ToString()] = t.builtinMethodYield(blockFrame, obj)
 				}
 			case 1:
 				arg := args[0]
 				for _, obj := range a.Elements {
-					switch b := t.builtinMethodYield(blockFrame, obj).Target; b.(type) {
+					switch b := t.builtinMethodYield(blockFrame, obj); b.(type) {
 					case *NullObject:
 						hash[obj.ToString()] = arg
 					default:
@@ -1104,8 +1104,7 @@ var builtinArrayInstanceMethods = []*BuiltinMethodObject{
 				}
 			} else {
 				for i, obj := range arr.Elements {
-					result := t.builtinMethodYield(blockFrame, obj)
-					elements[i] = result.Target
+					elements[i] = t.builtinMethodYield(blockFrame, obj)
 				}
 			}
 
@@ -1225,8 +1224,7 @@ var builtinArrayInstanceMethods = []*BuiltinMethodObject{
 			}
 
 			for i := start; i < len(arr.Elements); i++ {
-				result := t.builtinMethodYield(blockFrame, prev, arr.Elements[i])
-				prev = result.Target
+				prev = t.builtinMethodYield(blockFrame, prev, arr.Elements[i])
 			}
 
 			return prev
@@ -1405,7 +1403,7 @@ var builtinArrayInstanceMethods = []*BuiltinMethodObject{
 
 			for _, obj := range arr.Elements {
 				result := t.builtinMethodYield(blockFrame, obj)
-				if result.Target.isTruthy() {
+				if result.isTruthy() {
 					elements = append(elements, obj)
 				}
 			}
diff --git a/vm/block.go b/vm/block.go
@@ -115,7 +115,7 @@ var builtinBlockInstanceMethods = []*BuiltinMethodObject{
 			c.self = block.self
 			c.isBlock = true
 
-			return t.builtinMethodYield(c, args...).Target
+			return t.builtinMethodYield(c, args...)
 		},
 	},
 }
diff --git a/vm/class.go b/vm/class.go
@@ -1199,9 +1199,8 @@ var builtinClassCommonInstanceMethods = []*BuiltinMethodObject{
 			}
 
 			blockFrame.self = receiver
-			result := t.builtinMethodYield(blockFrame)
 
-			return result.Target
+			return t.builtinMethodYield(blockFrame)
 
 		},
 	},
diff --git a/vm/concurrent_rw_lock.go b/vm/concurrent_rw_lock.go
@@ -170,7 +170,7 @@ var builtinConcurrentRWLockInstanceMethods = []*BuiltinMethodObject{
 
 			lockObject.mutex.RLock()
 
-			blockReturnValue := t.builtinMethodYield(blockFrame).Target
+			blockReturnValue := t.builtinMethodYield(blockFrame)
 
 			lockObject.mutex.RUnlock()
 
@@ -204,7 +204,7 @@ var builtinConcurrentRWLockInstanceMethods = []*BuiltinMethodObject{
 
 			lockObject.mutex.Lock()
 
-			blockReturnValue := t.builtinMethodYield(blockFrame).Target
+			blockReturnValue := t.builtinMethodYield(blockFrame)
 
 			lockObject.mutex.Unlock()
 
diff --git a/vm/hash.go b/vm/hash.go
@@ -216,7 +216,7 @@ var builtinHashInstanceMethods = []*BuiltinMethodObject{
 					return NULL
 				}
 
-				if result.Target.isTruthy() {
+				if result.isTruthy() {
 					return TRUE
 				}
 			}
@@ -384,13 +384,13 @@ var builtinHashInstanceMethods = []*BuiltinMethodObject{
 				objectKey := t.vm.InitStringObject(stringKey)
 				result := t.builtinMethodYield(blockFrame, objectKey, value)
 
-				booleanResult, isResultBoolean := result.Target.(*BooleanObject)
+				booleanResult, isResultBoolean := result.(*BooleanObject)
 
 				if isResultBoolean {
 					if booleanResult.value {
 						delete(hash.Pairs, stringKey)
 					}
-				} else if result.Target != NULL {
+				} else if result != NULL {
 					delete(hash.Pairs, stringKey)
 				}
 			}
@@ -704,7 +704,7 @@ var builtinHashInstanceMethods = []*BuiltinMethodObject{
 			}
 
 			if blockFrame != nil {
-				return t.builtinMethodYield(blockFrame, key).Target
+				return t.builtinMethodYield(blockFrame, key)
 			}
 			return t.vm.InitErrorObject(errors.ArgumentError, sourceLine, "The value was not found, and no block has been provided")
 		},
@@ -746,7 +746,7 @@ var builtinHashInstanceMethods = []*BuiltinMethodObject{
 
 				if !ok {
 					if blockFrame != nil {
-						value = t.builtinMethodYield(blockFrame, objectKey).Target
+						value = t.builtinMethodYield(blockFrame, objectKey)
 						blockFramePopped = true
 					} else {
 						return t.vm.InitErrorObject(errors.ArgumentError, sourceLine, "There is no value for the key `%s`, and no block has been provided", stringKey.value)
@@ -910,7 +910,7 @@ var builtinHashInstanceMethods = []*BuiltinMethodObject{
 			}
 
 			for k, v := range h.Pairs {
-				result[k] = t.builtinMethodYield(blockFrame, v).Target
+				result[k] = t.builtinMethodYield(blockFrame, v)
 			}
 			return t.vm.InitHashObject(result)
 
@@ -1005,7 +1005,7 @@ var builtinHashInstanceMethods = []*BuiltinMethodObject{
 				objectKey := t.vm.InitStringObject(stringKey)
 				result := t.builtinMethodYield(blockFrame, objectKey, value)
 
-				if result.Target.isTruthy() {
+				if result.isTruthy() {
 					destinationPairs[stringKey] = value
 				}
 			}
@@ -1179,8 +1179,7 @@ var builtinHashInstanceMethods = []*BuiltinMethodObject{
 
 			resultHash := make(map[string]Object)
 			for k, v := range h.Pairs {
-				result := t.builtinMethodYield(blockFrame, v)
-				resultHash[k] = result.Target
+				resultHash[k] = t.builtinMethodYield(blockFrame, v)
 			}
 			return t.vm.InitHashObject(resultHash)
 
diff --git a/vm/http.go b/vm/http.go
@@ -168,11 +168,11 @@ var builtinHTTPClassMethods = []*BuiltinMethodObject{
 
 			result := t.builtinMethodYield(blockFrame, gobyClient)
 
-			if err, ok := result.Target.(*Error); ok {
+			if err, ok := result.(*Error); ok {
 				return err //an Error object
 			}
 
-			return result.Target
+			return result
 
 		},
 	},
diff --git a/vm/range.go b/vm/range.go
@@ -119,7 +119,7 @@ var builtinRangeInstanceMethods = []*BuiltinMethodObject{
 
 				result := t.builtinMethodYield(blockFrame, t.vm.InitIntegerObject(mid))
 
-				switch r := result.Target.(type) {
+				switch r := result.(type) {
 				case *BooleanObject:
 					if r.value {
 						pivot = mid
@@ -303,7 +303,7 @@ var builtinRangeInstanceMethods = []*BuiltinMethodObject{
 					el = append(el, NULL)
 				} else {
 					obj := t.vm.InitIntegerObject(i)
-					el = append(el, t.builtinMethodYield(blockFrame, obj).Target)
+					el = append(el, t.builtinMethodYield(blockFrame, obj))
 				}
 
 				return nil
diff --git a/vm/simple_server.go b/vm/simple_server.go
@@ -152,7 +152,7 @@ func newHandler(t *Thread, blockFrame *normalCallFrame) func(http.ResponseWriter
 		req := initRequest(t, w, r)
 		result := thread.builtinMethodYield(blockFrame, req, res)
 
-		if err, ok := result.Target.(*Error); ok {
+		if err, ok := result.(*Error); ok {
 			log.Printf("Error: %s", err.message)
 			res.InstanceVariableSet("@status", t.vm.InitIntegerObject(500))
 		}
diff --git a/vm/thread.go b/vm/thread.go
@@ -240,7 +240,7 @@ func (t *Thread) execInstruction(cf *normalCallFrame, i *bytecode.Instruction) {
 }
 
 // Yield to a call frame
-func (t *Thread) Yield(args ...Object) *Pointer {
+func (t *Thread) Yield(args ...Object) Object {
 	return t.builtinMethodYield(t.currentFrame.BlockFrame(), args...)
 }
 
@@ -249,9 +249,9 @@ func (t *Thread) BlockGiven() bool {
 	return t.currentFrame.BlockFrame() != nil
 }
 
-func (t *Thread) builtinMethodYield(blockFrame *normalCallFrame, args ...Object) *Pointer {
+func (t *Thread) builtinMethodYield(blockFrame *normalCallFrame, args ...Object) Object {
 	if blockFrame.IsRemoved() {
-		return &Pointer{Target: NULL}
+		return NULL
 	}
 
 	c := newNormalCallFrame(blockFrame.instructionSet, blockFrame.FileName(), blockFrame.sourceLine)
@@ -269,10 +269,10 @@ func (t *Thread) builtinMethodYield(blockFrame *normalCallFrame, args ...Object)
 	t.startFromTopFrame()
 
 	if blockFrame.IsRemoved() {
-		return &Pointer{Target: NULL}
+		return NULL
 	}
 
-	return t.Stack.top()
+	return t.Stack.top().Target
 }
 
 func (t *Thread) retrieveBlock(fileName, blockFlag string, sourceLine int) (blockFrame *normalCallFrame) {

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ var builtinArrayClassMethods = []*BuiltinMethodObject{`
`44`	`44`
`45`	`45`	`if blockFrame != nil && !blockIsEmpty(blockFrame) {`
`46`	`46`	`for i := range elems {`
`47`		`- elems[i] = t.builtinMethodYield(blockFrame, t.vm.InitIntegerObject(i)).Target`
	`47`	`+ elems[i] = t.builtinMethodYield(blockFrame, t.vm.InitIntegerObject(i))`
`48`	`48`	`}`
`49`	`49`	`} else {`
`50`	`50`	`var elem Object`
`@@ -413,7 +413,7 @@ var builtinArrayInstanceMethods = []*BuiltinMethodObject{`
`413`	`413`	`for _, obj := range arr.Elements {`
`414`	`414`	`result := t.builtinMethodYield(blockFrame, obj)`
`415`	`415`
`416`		`- if result.Target.isTruthy() {`
	`416`	`+ if result.isTruthy() {`
`417`	`417`	`return TRUE`
`418`	`418`	`}`
`419`	`419`	`}`
`@@ -541,7 +541,7 @@ var builtinArrayInstanceMethods = []*BuiltinMethodObject{`
`541`	`541`
`542`	`542`	`for _, obj := range arr.Elements {`
`543`	`543`	`result := t.builtinMethodYield(blockFrame, obj)`
`544`		`- if result.Target.isTruthy() {`
	`544`	`+ if result.isTruthy() {`
`545`	`545`	`count++`
`546`	`546`	`}`
`547`	`547`	`}`
`@@ -930,12 +930,12 @@ var builtinArrayInstanceMethods = []*BuiltinMethodObject{`
`930`	`930`	`switch len(args) {`
`931`	`931`	`case 0:`
`932`	`932`	`for _, obj := range a.Elements {`
`933`		`- hash[obj.ToString()] = t.builtinMethodYield(blockFrame, obj).Target`
	`933`	`+ hash[obj.ToString()] = t.builtinMethodYield(blockFrame, obj)`
`934`	`934`	`}`
`935`	`935`	`case 1:`
`936`	`936`	`arg := args[0]`
`937`	`937`	`for _, obj := range a.Elements {`
`938`		`- switch b := t.builtinMethodYield(blockFrame, obj).Target; b.(type) {`
	`938`	`+ switch b := t.builtinMethodYield(blockFrame, obj); b.(type) {`
`939`	`939`	`case *NullObject:`
`940`	`940`	`hash[obj.ToString()] = arg`
`941`	`941`	`default:`
`@@ -1104,8 +1104,7 @@ var builtinArrayInstanceMethods = []*BuiltinMethodObject{`
`1104`	`1104`	`}`
`1105`	`1105`	`} else {`
`1106`	`1106`	`for i, obj := range arr.Elements {`
`1107`		`- result := t.builtinMethodYield(blockFrame, obj)`
`1108`		`- elements[i] = result.Target`
	`1107`	`+ elements[i] = t.builtinMethodYield(blockFrame, obj)`
`1109`	`1108`	`}`
`1110`	`1109`	`}`
`1111`	`1110`
`@@ -1225,8 +1224,7 @@ var builtinArrayInstanceMethods = []*BuiltinMethodObject{`
`1225`	`1224`	`}`
`1226`	`1225`
`1227`	`1226`	`for i := start; i < len(arr.Elements); i++ {`
`1228`		`- result := t.builtinMethodYield(blockFrame, prev, arr.Elements[i])`
`1229`		`- prev = result.Target`
	`1227`	`+ prev = t.builtinMethodYield(blockFrame, prev, arr.Elements[i])`
`1230`	`1228`	`}`
`1231`	`1229`
`1232`	`1230`	`return prev`
`@@ -1405,7 +1403,7 @@ var builtinArrayInstanceMethods = []*BuiltinMethodObject{`
`1405`	`1403`
`1406`	`1404`	`for _, obj := range arr.Elements {`
`1407`	`1405`	`result := t.builtinMethodYield(blockFrame, obj)`
`1408`		`- if result.Target.isTruthy() {`
	`1406`	`+ if result.isTruthy() {`
`1409`	`1407`	`elements = append(elements, obj)`
`1410`	`1408`	`}`
`1411`	`1409`	`}`
Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ var builtinBlockInstanceMethods = []*BuiltinMethodObject{`
`115`	`115`	`c.self = block.self`
`116`	`116`	`c.isBlock = true`
`117`	`117`
`118`		`- return t.builtinMethodYield(c, args...).Target`
	`118`	`+ return t.builtinMethodYield(c, args...)`
`119`	`119`	`},`
`120`	`120`	`},`
`121`	`121`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1199,9 +1199,8 @@ var builtinClassCommonInstanceMethods = []*BuiltinMethodObject{`
`1199`	`1199`	`}`
`1200`	`1200`
`1201`	`1201`	`blockFrame.self = receiver`
`1202`		`- result := t.builtinMethodYield(blockFrame)`
`1203`	`1202`
`1204`		`- return result.Target`
	`1203`	`+ return t.builtinMethodYield(blockFrame)`
`1205`	`1204`
`1206`	`1205`	`},`
`1207`	`1206`	`},`
Original file line number	Diff line number	Diff line change
`@@ -216,7 +216,7 @@ var builtinHashInstanceMethods = []*BuiltinMethodObject{`
`216`	`216`	`return NULL`
`217`	`217`	`}`
`218`	`218`
`219`		`- if result.Target.isTruthy() {`
	`219`	`+ if result.isTruthy() {`
`220`	`220`	`return TRUE`
`221`	`221`	`}`
`222`	`222`	`}`
`@@ -384,13 +384,13 @@ var builtinHashInstanceMethods = []*BuiltinMethodObject{`
`384`	`384`	`objectKey := t.vm.InitStringObject(stringKey)`
`385`	`385`	`result := t.builtinMethodYield(blockFrame, objectKey, value)`
`386`	`386`
`387`		`- booleanResult, isResultBoolean := result.Target.(*BooleanObject)`
	`387`	`+ booleanResult, isResultBoolean := result.(*BooleanObject)`
`388`	`388`
`389`	`389`	`if isResultBoolean {`
`390`	`390`	`if booleanResult.value {`
`391`	`391`	`delete(hash.Pairs, stringKey)`
`392`	`392`	`}`
`393`		`- } else if result.Target != NULL {`
	`393`	`+ } else if result != NULL {`
`394`	`394`	`delete(hash.Pairs, stringKey)`
`395`	`395`	`}`
`396`	`396`	`}`
`@@ -704,7 +704,7 @@ var builtinHashInstanceMethods = []*BuiltinMethodObject{`
`704`	`704`	`}`
`705`	`705`
`706`	`706`	`if blockFrame != nil {`
`707`		`- return t.builtinMethodYield(blockFrame, key).Target`
	`707`	`+ return t.builtinMethodYield(blockFrame, key)`
`708`	`708`	`}`
`709`	`709`	`return t.vm.InitErrorObject(errors.ArgumentError, sourceLine, "The value was not found, and no block has been provided")`
`710`	`710`	`},`
`@@ -746,7 +746,7 @@ var builtinHashInstanceMethods = []*BuiltinMethodObject{`
`746`	`746`
`747`	`747`	`if !ok {`
`748`	`748`	`if blockFrame != nil {`
`749`		`- value = t.builtinMethodYield(blockFrame, objectKey).Target`
	`749`	`+ value = t.builtinMethodYield(blockFrame, objectKey)`
`750`	`750`	`blockFramePopped = true`
`751`	`751`	`} else {`
`752`	`752`	return t.vm.InitErrorObject(errors.ArgumentError, sourceLine, "There is no value for the key `%s`, and no block has been provided", stringKey.value)
`@@ -910,7 +910,7 @@ var builtinHashInstanceMethods = []*BuiltinMethodObject{`
`910`	`910`	`}`
`911`	`911`
`912`	`912`	`for k, v := range h.Pairs {`
`913`		`- result[k] = t.builtinMethodYield(blockFrame, v).Target`
	`913`	`+ result[k] = t.builtinMethodYield(blockFrame, v)`
`914`	`914`	`}`
`915`	`915`	`return t.vm.InitHashObject(result)`
`916`	`916`
`@@ -1005,7 +1005,7 @@ var builtinHashInstanceMethods = []*BuiltinMethodObject{`
`1005`	`1005`	`objectKey := t.vm.InitStringObject(stringKey)`
`1006`	`1006`	`result := t.builtinMethodYield(blockFrame, objectKey, value)`
`1007`	`1007`
`1008`		`- if result.Target.isTruthy() {`
	`1008`	`+ if result.isTruthy() {`
`1009`	`1009`	`destinationPairs[stringKey] = value`
`1010`	`1010`	`}`
`1011`	`1011`	`}`
`@@ -1179,8 +1179,7 @@ var builtinHashInstanceMethods = []*BuiltinMethodObject{`
`1179`	`1179`
`1180`	`1180`	`resultHash := make(map[string]Object)`
`1181`	`1181`	`for k, v := range h.Pairs {`
`1182`		`- result := t.builtinMethodYield(blockFrame, v)`
`1183`		`- resultHash[k] = result.Target`
	`1182`	`+ resultHash[k] = t.builtinMethodYield(blockFrame, v)`
`1184`	`1183`	`}`
`1185`	`1184`	`return t.vm.InitHashObject(resultHash)`
`1186`	`1185`
Original file line number	Diff line number	Diff line change
`@@ -152,7 +152,7 @@ func newHandler(t Thread, blockFrame normalCallFrame) func(http.ResponseWriter`
`152`	`152`	`req := initRequest(t, w, r)`
`153`	`153`	`result := thread.builtinMethodYield(blockFrame, req, res)`
`154`	`154`
`155`		`- if err, ok := result.Target.(*Error); ok {`
	`155`	`+ if err, ok := result.(*Error); ok {`
`156`	`156`	`log.Printf("Error: %s", err.message)`
`157`	`157`	`res.InstanceVariableSet("@status", t.vm.InitIntegerObject(500))`
`158`	`158`	`}`
Original file line number	Diff line number	Diff line change
`@@ -240,7 +240,7 @@ func (t Thread) execInstruction(cf normalCallFrame, i *bytecode.Instruction) {`
`240`	`240`	`}`
`241`	`241`
`242`	`242`	`// Yield to a call frame`
`243`		`-func (t Thread) Yield(args ...Object) Pointer {`
	`243`	`+func (t *Thread) Yield(args ...Object) Object {`
`244`	`244`	`return t.builtinMethodYield(t.currentFrame.BlockFrame(), args...)`
`245`	`245`	`}`
`246`	`246`
`@@ -249,9 +249,9 @@ func (t *Thread) BlockGiven() bool {`
`249`	`249`	`return t.currentFrame.BlockFrame() != nil`
`250`	`250`	`}`
`251`	`251`
`252`		`-func (t Thread) builtinMethodYield(blockFrame normalCallFrame, args ...Object) *Pointer {`
	`252`	`+func (t Thread) builtinMethodYield(blockFrame normalCallFrame, args ...Object) Object {`
`253`	`253`	`if blockFrame.IsRemoved() {`
`254`		`- return &Pointer{Target: NULL}`
	`254`	`+ return NULL`
`255`	`255`	`}`
`256`	`256`
`257`	`257`	`c := newNormalCallFrame(blockFrame.instructionSet, blockFrame.FileName(), blockFrame.sourceLine)`
`@@ -269,10 +269,10 @@ func (t Thread) builtinMethodYield(blockFrame normalCallFrame, args ...Object)`
`269`	`269`	`t.startFromTopFrame()`
`270`	`270`
`271`	`271`	`if blockFrame.IsRemoved() {`
`272`		`- return &Pointer{Target: NULL}`
	`272`	`+ return NULL`
`273`	`273`	`}`
`274`	`274`
`275`		`- return t.Stack.top()`
	`275`	`+ return t.Stack.top().Target`
`276`	`276`	`}`
`277`	`277`
`278`	`278`	`func (t Thread) retrieveBlock(fileName, blockFlag string, sourceLine int) (blockFrame normalCallFrame) {`