publishing rename

Ducasse · Ducasse · commit 214aaed9b879 · 2024-12-20T10:13:01.000+01:00
diff --git a/src/Sindarin-Tests/SindarinDebugSessionTest.class.st b/src/Sindarin-Tests/SindarinDebugSessionTest.class.st
@@ -42,7 +42,7 @@ SindarinDebugSessionTest >> testSindarinSessionInstantiation [
 	sindarinSession := SindarinDebugSession
 		                   newWithName: sessionName
 		                   forProcess: process.
-	self assert: sindarinSession debugSession notNil.
+	self assert: sindarinSession debugSession isNotNil.
 	self assert: sindarinSession debugSession name equals: sessionName.
 	self
 		assert: sindarinSession debugSession process
diff --git a/src/Sindarin-Tests/SindarinDebuggerTest.class.st b/src/Sindarin-Tests/SindarinDebuggerTest.class.st
@@ -2040,8 +2040,8 @@ SindarinDebuggerTest >> testTemporaryNamed [
 SindarinDebuggerTest >> testTerminate [
 	| dbg |
 	dbg := SindarinDebugger debug: [ self helperMethod13 ].
-	self assert: dbg debugSession interruptedContext notNil.
-	self assert: dbg debugSession interruptedProcess notNil.
+	self assert: dbg debugSession interruptedContext isNotNil.
+	self assert: dbg debugSession interruptedProcess isNotNil.
 	dbg terminate.
 	self assert: dbg debugSession interruptedContext isNil.
 	self assert: dbg debugSession interruptedProcess isNil.
diff --git a/src/Sindarin/OCBlockNode.extension.st b/src/Sindarin/OCBlockNode.extension.st
@@ -1,7 +1,7 @@
-Extension { #name : 'RBBlockNode' }
+Extension { #name : 'OCBlockNode' }
 
 { #category : '*Sindarin' }
-RBBlockNode >> executedNodesAfter: aNode [
+OCBlockNode >> executedNodesAfter: aNode [
 
 	"Gives all nodes that are executed after aNode. Assuming that aNode is a recursive child, then all nodes executed after it are all nodes after it in allChildrenPostOrder"
 
@@ -14,13 +14,13 @@ RBBlockNode >> executedNodesAfter: aNode [
 ]
 
 { #category : '*Sindarin' }
-RBBlockNode >> firstPCOfStatement: aStatementNode [
+OCBlockNode >> firstPCOfStatement: aStatementNode [
 
 	^ self bcToASTCache firstRecursiveBcOffsetForStatementNode: aStatementNode
 ]
 
 { #category : '*Sindarin' }
-RBBlockNode >> nextExecutedNodeAfter: aNode [
+OCBlockNode >> nextExecutedNodeAfter: aNode [
 
 	"Find first node that is after aNode that has an associated pc in method node all children (post-order)"
 
@@ -32,7 +32,7 @@ RBBlockNode >> nextExecutedNodeAfter: aNode [
 ]
 
 { #category : '*Sindarin' }
-RBBlockNode >> parentOfIdenticalSubtree: subtree [
+OCBlockNode >> parentOfIdenticalSubtree: subtree [
 
 	^ self allChildren reversed
 		  detect: [ :e | e == subtree ]
@@ -41,7 +41,7 @@ RBBlockNode >> parentOfIdenticalSubtree: subtree [
 ]
 
 { #category : '*Sindarin' }
-RBBlockNode >> skipWithDebugger: aSindarinDebugger [
+OCBlockNode >> skipWithDebugger: aSindarinDebugger [
 
 	aSindarinDebugger skipBlockNode 
 ]
diff --git a/src/Sindarin/OCBytecodeToASTCache.extension.st b/src/Sindarin/OCBytecodeToASTCache.extension.st
@@ -3,6 +3,6 @@ Extension { #name : 'OCBytecodeToASTCache' }
 { #category : '*Sindarin' }
 OCBytecodeToASTCache >> firstRecursiveBcOffsetForStatementNode: aStatementNode [
 
-	^ self methodOrBlockNode bcToASTCache bcToASTMap keys sorted detect: [ 
-		  :key | (self nodeForPC: key) statementNode == aStatementNode ]
+	^ self methodOrBlockNode bcToASTCache bcToASTMap keys sorted 
+		detect: [ :key | (self nodeForPC: key) statementNode == aStatementNode ]
 ]
diff --git a/src/Sindarin/OCMessageNode.extension.st b/src/Sindarin/OCMessageNode.extension.st
@@ -0,0 +1,7 @@
+Extension { #name : 'OCMessageNode' }
+
+{ #category : '*Sindarin' }
+OCMessageNode >> skipWithDebugger: aSindarinDebugger [
+
+	aSindarinDebugger skipMessageNode 
+]
diff --git a/src/Sindarin/OCMethodNode.extension.st b/src/Sindarin/OCMethodNode.extension.st
@@ -1,7 +1,7 @@
-Extension { #name : 'RBMethodNode' }
+Extension { #name : 'OCMethodNode' }
 
 { #category : '*Sindarin' }
-RBMethodNode >> executedNodesAfter: aNode [
+OCMethodNode >> executedNodesAfter: aNode [
 
 	"Gives all nodes that are executed after aNode. Assuming that aNode is a recursive child, then all nodes executed after it are all nodes after it in allChildrenPostOrder"
 
@@ -14,13 +14,13 @@ RBMethodNode >> executedNodesAfter: aNode [
 ]
 
 { #category : '*Sindarin' }
-RBMethodNode >> firstPCOfStatement: aStatementNode [
+OCMethodNode >> firstPCOfStatement: aStatementNode [
 
 	^ self bcToASTCache firstRecursiveBcOffsetForStatementNode: aStatementNode
 ]
 
 { #category : '*Sindarin' }
-RBMethodNode >> nextExecutedNodeAfter: aNode [
+OCMethodNode >> nextExecutedNodeAfter: aNode [
 
 	"Find first node that is after aNode that has an associated pc in method node all children (post-order)"
 
@@ -32,7 +32,7 @@ RBMethodNode >> nextExecutedNodeAfter: aNode [
 ]
 
 { #category : '*Sindarin' }
-RBMethodNode >> parentOfIdenticalSubtree: subtree [
+OCMethodNode >> parentOfIdenticalSubtree: subtree [
 
 	^ self allChildren reversed
 		  detect: [ :e | e == subtree ]
@@ -41,7 +41,7 @@ RBMethodNode >> parentOfIdenticalSubtree: subtree [
 ]
 
 { #category : '*Sindarin' }
-RBMethodNode >> statementNodeContaining: aNode [
+OCMethodNode >> statementNodeContaining: aNode [
 
 	| statementNode parentOfStatementNode |
 	statementNode := aNode.
diff --git a/src/Sindarin/OCProgramNode.extension.st b/src/Sindarin/OCProgramNode.extension.st
@@ -1,7 +1,7 @@
-Extension { #name : 'RBProgramNode' }
+Extension { #name : 'OCProgramNode' }
 
 { #category : '*Sindarin' }
-RBProgramNode >> allChildrenPostOrder [
+OCProgramNode >> allChildrenPostOrder [
 
 	| children |
 	children := OrderedCollection new.
@@ -12,7 +12,7 @@ RBProgramNode >> allChildrenPostOrder [
 ]
 
 { #category : '*Sindarin' }
-RBProgramNode >> skipWithDebugger: aSindarinDebugger [
+OCProgramNode >> skipWithDebugger: aSindarinDebugger [
 
 	aSindarinDebugger step
 ]
diff --git a/src/Sindarin/OCReturnNode.extension.st b/src/Sindarin/OCReturnNode.extension.st
@@ -0,0 +1,7 @@
+Extension { #name : 'OCReturnNode' }
+
+{ #category : '*Sindarin' }
+OCReturnNode >> skipWithDebugger: aSindarinDebugger [
+
+	aSindarinDebugger skipReturnNode
+]
diff --git a/src/Sindarin/Process.extension.st b/src/Sindarin/Process.extension.st
@@ -4,6 +4,6 @@ Extension { #name : 'Process' }
 Process >> stepToSendOrReturnOrJump [
 
 	^Processor activeProcess
-		evaluate: [suspendedContext := suspendedContext stepToSendOrReturnOrJump]
+		evaluate: [ suspendedContext := suspendedContext stepToSendOrReturnOrJump ]
 		onBehalfOf: self
 ]
diff --git a/src/Sindarin/RBAssignmentNode.extension.st b/src/Sindarin/RBAssignmentNode.extension.st
diff --git a/src/Sindarin/RBBlockDefinitionSearchingVisitor.class.st b/src/Sindarin/RBBlockDefinitionSearchingVisitor.class.st
@@ -1,6 +1,6 @@
 Class {
 	#name : 'RBBlockDefinitionSearchingVisitor',
-	#superclass : 'RBProgramNodeVisitor',
+	#superclass : 'OCProgramNodeVisitor',
 	#instVars : [
 		'blockToSearch',
 		'isBlockFound'
diff --git a/src/Sindarin/RBMessageNode.extension.st b/src/Sindarin/RBMessageNode.extension.st
diff --git a/src/Sindarin/RBReturnNode.extension.st b/src/Sindarin/RBReturnNode.extension.st
diff --git a/src/Sindarin/SindarinDebugger.class.st b/src/Sindarin/SindarinDebugger.class.st
@@ -112,7 +112,7 @@ SindarinDebugger >> isAboutToInstantiateClass [
 	self isMessageSend ifFalse: [ ^ false ].
 	methodAboutToExecute := self receiver class lookupSelector:
 		                        self node selector.
-	^ methodAboutToExecute notNil and: [ 
+	^ methodAboutToExecute isNotNil and: [ 
 		  self instanceCreationPrimitives includes:
 			  methodAboutToExecute primitive ]
 ]
diff --git a/src/Sindarin/TSindarin.trait.st b/src/Sindarin/TSindarin.trait.st
@@ -126,7 +126,7 @@ TSindarin >> instanceCreationPrimitives [
 	"* 70 */ primitiveNew,
 	/* 71 */ primitiveNewWithArg,
 	/* 79 */ primitiveNewMethod,
-	/* 148 */ primitiveClone,
+	/* 148 */ primitiveClone, 
 	/* 160 */ primitiveAdoptInstance"
 
 	self flag: 'These numbers may have changed. This is to be checked'.
@@ -161,7 +161,7 @@ TSindarin >> method [
 	"Returns the method of the current stack-frame."
 
 	self flag:
-		'There is something bad here. Context>>#method returns a CompiledCode that can be a CompiledBlock. So the naming of the method is not completely correct. We should distinguish method and methodOrBlock'.
+		'There is something bad here. Context >> #method returns a CompiledCode that can be a CompiledBlock. So the naming of the method is not completely correct. We should distinguish method and methodOrBlock'.
 	^ self context method
 ]
 

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`		`-Extension { #name : 'RBBlockNode' }`
	`1`	`+Extension { #name : 'OCBlockNode' }`
`2`	`2`
`3`	`3`	`{ #category : '*Sindarin' }`
`4`		`-RBBlockNode >> executedNodesAfter: aNode [`
	`4`	`+OCBlockNode >> executedNodesAfter: aNode [`
`5`	`5`
`6`	`6`	`"Gives all nodes that are executed after aNode. Assuming that aNode is a recursive child, then all nodes executed after it are all nodes after it in allChildrenPostOrder"`
`7`	`7`
`@@ -14,13 +14,13 @@ RBBlockNode >> executedNodesAfter: aNode [`
`14`	`14`	`]`
`15`	`15`
`16`	`16`	`{ #category : '*Sindarin' }`
`17`		`-RBBlockNode >> firstPCOfStatement: aStatementNode [`
	`17`	`+OCBlockNode >> firstPCOfStatement: aStatementNode [`
`18`	`18`
`19`	`19`	`^ self bcToASTCache firstRecursiveBcOffsetForStatementNode: aStatementNode`
`20`	`20`	`]`
`21`	`21`
`22`	`22`	`{ #category : '*Sindarin' }`
`23`		`-RBBlockNode >> nextExecutedNodeAfter: aNode [`
	`23`	`+OCBlockNode >> nextExecutedNodeAfter: aNode [`
`24`	`24`
`25`	`25`	`"Find first node that is after aNode that has an associated pc in method node all children (post-order)"`
`26`	`26`
`@@ -32,7 +32,7 @@ RBBlockNode >> nextExecutedNodeAfter: aNode [`
`32`	`32`	`]`
`33`	`33`
`34`	`34`	`{ #category : '*Sindarin' }`
`35`		`-RBBlockNode >> parentOfIdenticalSubtree: subtree [`
	`35`	`+OCBlockNode >> parentOfIdenticalSubtree: subtree [`
`36`	`36`
`37`	`37`	`^ self allChildren reversed`
`38`	`38`	`detect: [ :e \| e == subtree ]`
`@@ -41,7 +41,7 @@ RBBlockNode >> parentOfIdenticalSubtree: subtree [`
`41`	`41`	`]`
`42`	`42`
`43`	`43`	`{ #category : '*Sindarin' }`
`44`		`-RBBlockNode >> skipWithDebugger: aSindarinDebugger [`
	`44`	`+OCBlockNode >> skipWithDebugger: aSindarinDebugger [`
`45`	`45`
`46`	`46`	`aSindarinDebugger skipBlockNode`
`47`	`47`	`]`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,6 @@ Extension { #name : 'OCBytecodeToASTCache' }`
`3`	`3`	`{ #category : '*Sindarin' }`
`4`	`4`	`OCBytecodeToASTCache >> firstRecursiveBcOffsetForStatementNode: aStatementNode [`
`5`	`5`
`6`		`- ^ self methodOrBlockNode bcToASTCache bcToASTMap keys sorted detect: [`
`7`		`- :key \| (self nodeForPC: key) statementNode == aStatementNode ]`
	`6`	`+ ^ self methodOrBlockNode bcToASTCache bcToASTMap keys sorted`
	`7`	`+ detect: [ :key \| (self nodeForPC: key) statementNode == aStatementNode ]`
`8`	`8`	`]`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`		`-Extension { #name : 'RBProgramNode' }`
	`1`	`+Extension { #name : 'OCProgramNode' }`
`2`	`2`
`3`	`3`	`{ #category : '*Sindarin' }`
`4`		`-RBProgramNode >> allChildrenPostOrder [`
	`4`	`+OCProgramNode >> allChildrenPostOrder [`
`5`	`5`
`6`	`6`	`\| children \|`
`7`	`7`	`children := OrderedCollection new.`
`@@ -12,7 +12,7 @@ RBProgramNode >> allChildrenPostOrder [`
`12`	`12`	`]`
`13`	`13`
`14`	`14`	`{ #category : '*Sindarin' }`
`15`		`-RBProgramNode >> skipWithDebugger: aSindarinDebugger [`
	`15`	`+OCProgramNode >> skipWithDebugger: aSindarinDebugger [`
`16`	`16`
`17`	`17`	`aSindarinDebugger step`
`18`	`18`	`]`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,6 @@ Extension { #name : 'Process' }`
`4`	`4`	`Process >> stepToSendOrReturnOrJump [`
`5`	`5`
`6`	`6`	`^Processor activeProcess`
`7`		`- evaluate: [suspendedContext := suspendedContext stepToSendOrReturnOrJump]`
	`7`	`+ evaluate: [ suspendedContext := suspendedContext stepToSendOrReturnOrJump ]`
`8`	`8`	`onBehalfOf: self`
`9`	`9`	`]`