The Trunk: Compiler-eem.342.mcz

Eliot Miranda uploaded a new version of Compiler to project The Trunk:
http://source.squeak.org/trunk/Compiler-eem.342.mcz

==================== Summary ====================

Name: Compiler-eem.342
Author: eem
Time: 5 April 2017, 6:17:30.333161 pm
UUID: 6a05266a-a653-41b9-bd16-577f666b4c98
Ancestors: Compiler-eem.341

Remove most of, if not all, old pre-closure-bytecode and blue-book block support from the compiler.

Recategorize code generation (size & emit methods) under "code generation", leaving closure analysis in "code generation (closures)" (to be changed later).

Eliminate the short-0form brace node creation code (which has used the cons array bytecode since the closure bytecodes).

=============== Diff against Compiler-eem.341 ===============

Item was changed:
+ ----- Method: BlockNode>>constructClosureCreationNode: (in category 'code generation') -----
- ----- Method: BlockNode>>constructClosureCreationNode: (in category 'code generation (closures)') -----
  constructClosureCreationNode: encoder
  copiedValues := self computeCopiedValues: encoder rootNode.
+ ^self ensureClosureCreationNode!
- encoder supportsClosureOpcodes ifTrue:
- [^self closureCreationNode].
- "Without the bytecode we can still get by."
- ^MessageNode new
- receiver: (encoder encodeVariable: 'thisContext')
- selector: #closureCopy:copiedValues:
- arguments: (Array
- with: (encoder encodeLiteral: arguments size)
- with: (copiedValues isEmpty
- ifTrue: [NodeNil]
- ifFalse: [BraceNode new elements: copiedValues]))
- precedence: 3
- from: encoder!

Item was removed:
- ----- Method: BlockNode>>emitCodeForClosureValue:encoder: (in category 'code generation (closures)') -----
- emitCodeForClosureValue: stack encoder: encoder
- "if not supportsClosureOpcodes closureCreationSupportNode is the
- node for thisContext closureCopy: numArgs [ copiedValues: { values } ]"
- encoder supportsClosureOpcodes
- ifTrue:
- [copiedValues do:
- [:copiedValue| copiedValue emitCodeForValue: stack encoder: encoder].
- closureCreationNode pc: encoder methodStreamPosition + 1.
- encoder
- genPushClosureCopyNumCopiedValues: copiedValues size
- numArgs: arguments size
- jumpSize: size.
- stack
- pop: copiedValues size;
- push: 1]
- ifFalse:
- [closureCreationNode emitCodeForValue: stack encoder: encoder.
- encoder genJumpLong: size]. "Force a two byte jump."
- "Emit the body of the block"
- self emitCodeForEvaluatedClosureValue: stack encoder: encoder!

Item was changed:
+ ----- Method: BlockNode>>emitCodeForEvaluatedClosureValue:encoder: (in category 'code generation') -----
- ----- Method: BlockNode>>emitCodeForEvaluatedClosureValue:encoder: (in category 'code generation (closures)') -----
  emitCodeForEvaluatedClosureValue: stack encoder: encoder
  | position |
  position := stack position.
  stack position: arguments size + temporaries size + copiedValues size.
  encoder genPushNClosureTemps: temporaries size.
  self
  reindexingLocalsDo: [self emitCodeForEvaluatedValue: stack encoder: encoder]
  encoder: encoder.
  self returns ifFalse:
  [encoder genReturnTopToCaller.
  pc := encoder methodStreamPosition].
  stack position: position!

Item was changed:
  ----- Method: BlockNode>>emitCodeForValue:encoder: (in category 'code generation') -----
  emitCodeForValue: stack encoder: encoder
+ copiedValues do:
+ [:copiedValue| copiedValue emitCodeForValue: stack encoder: encoder].
+ closureCreationNode pc: encoder methodStreamPosition + 1.
+ encoder
+ genPushClosureCopyNumCopiedValues: copiedValues size
+ numArgs: arguments size
+ jumpSize: size.
+ stack
+ pop: copiedValues size;
+ push: 1.
+ "Emit the body of the block"
+ self emitCodeForEvaluatedClosureValue: stack encoder: encoder!
-
- self generateAsClosure ifTrue:
- [^self emitCodeForClosureValue: stack encoder: encoder].
- encoder genPushThisContext.
- stack push: 1.
- nArgsNode emitCodeForValue: stack encoder: encoder.
- remoteCopyNode
- emitCode: stack
- args: 1
- encoder: encoder.
- "Force a two byte jump."
- encoder genJumpLong: size.
- stack push: arguments size.
- arguments reverseDo: [:arg | arg emitCodeForStorePop: stack encoder: encoder].
- self emitCodeForEvaluatedValue: stack encoder: encoder.
- self returns ifFalse:
- [encoder genReturnTopToCaller.
- pc := encoder methodStreamPosition].
- stack pop: 1!

Item was added:
+ ----- Method: BlockNode>>ensureClosureCreationNode (in category 'accessing') -----
+ ensureClosureCreationNode
+ closureCreationNode ifNil:
+ [closureCreationNode := LeafNode new
+ key: #closureCreationNode
+ code: nil].
+ ^closureCreationNode!

Item was removed:
- ----- Method: BlockNode>>generateAsClosure (in category 'testing') -----
- generateAsClosure
- "Answer if we're compiling under the closure regime.  If blockExtent has been set by
- analyseTempsWithin:rootNode: et al then we're compiling under the closure regime."
- ^blockExtent ~~ nil!

Item was changed:
  ----- Method: BlockNode>>noteSourceRangeStart:end:encoder: (in category 'initialize-release') -----
  noteSourceRangeStart: start end: end encoder: encoder
  "Note two source ranges for this node.  One is for the debugger
  and is of the last expression, the result of the block.  One is for
  source analysis and is for the entire block."
  encoder
  noteSourceRange: (start to: end)
+ forNode: self ensureClosureCreationNode.
- forNode: self closureCreationNode.
  startOfLastStatement
  ifNil:
  [encoder
  noteSourceRange: (start to: end)
  forNode: self]
  ifNotNil:
  [encoder
  noteSourceRange: (startOfLastStatement to: end - 1)
  forNode: self]!

Item was removed:
- ----- Method: BlockNode>>sizeCodeForClosureValue: (in category 'code generation (closures)') -----
- sizeCodeForClosureValue: encoder
- "Compute the size for the creation of the block and its code."
- "If we have the closure bytecodes constructClosureCreationNode: will note
- the copied values in the copiedValues inst var and answer #pushCopiedValues."
- closureCreationNode := self constructClosureCreationNode: encoder.
- "Remember size of body for emit time so we know the size of the jump around it."
- size := self sizeCodeForEvaluatedClosureValue: encoder.
- ^encoder supportsClosureOpcodes
- ifTrue:
- [(copiedValues inject: 0 into: [:sum :node| sum + (node sizeCodeForValue: encoder)])
- + (encoder sizePushClosureCopyNumCopiedValues: copiedValues size numArgs: arguments size jumpSize: size)
- + size]
- ifFalse:
- ["closureCreationSupportNode is send closureCopy:copiedValues:"
- (closureCreationNode sizeCodeForValue: encoder)
- + (encoder sizeJumpLong: size)
- + size]!

Item was changed:
+ ----- Method: BlockNode>>sizeCodeForEvaluatedClosureValue: (in category 'code generation') -----
- ----- Method: BlockNode>>sizeCodeForEvaluatedClosureValue: (in category 'code generation (closures)') -----
  sizeCodeForEvaluatedClosureValue: encoder
  "The closure value primitives push the arguments and the copied values.
  The compiler guarantees that any copied values come before all local temps.
  So on closure activation we only need to push nils for the remaining temporaries."
  ^(encoder sizePushNClosureTemps: temporaries size)
  + (self
  reindexingLocalsDo: [self sizeCodeForEvaluatedValue: encoder]
  encoder: nil "don't store temps yet")
  + (self returns ifTrue: [0] ifFalse: [encoder sizeReturnTopToCaller])!

Item was changed:
  ----- Method: BlockNode>>sizeCodeForValue: (in category 'code generation') -----
  sizeCodeForValue: encoder
+ "Compute the size for the creation of the block and its code."
+ copiedValues := self computeCopiedValues: encoder rootNode.
+ self ensureClosureCreationNode.
+ "Remember size of body for emit time so we know the size of the jump around it."
+ size := self sizeCodeForEvaluatedClosureValue: encoder.
+ ^(copiedValues inject: 0 into: [:sum :node| sum + (node sizeCodeForValue: encoder)])
+  + (encoder sizePushClosureCopyNumCopiedValues: copiedValues size numArgs: arguments size jumpSize: size)
+  + size!
- self generateAsClosure ifTrue:
- [^self sizeCodeForClosureValue: encoder].
-
- nArgsNode := encoder encodeLiteral: arguments size.
- remoteCopyNode := encoder encodeSelector: #blockCopy:.
- size := self sizeCodeForEvaluatedValue: encoder.
- self returns ifFalse:
- [size := size + encoder sizeReturnTopToCaller]. "endBlock"
- arguments := arguments collect:  "Chance to prepare debugger remote temps"
- [:arg | arg asStorableNode: encoder].
- arguments do: [:arg | size := size + (arg sizeCodeForStorePop: encoder)].
- ^encoder sizePushThisContext
- + (nArgsNode sizeCodeForValue: encoder)
- + (remoteCopyNode sizeCode: encoder args: 1 super: false)
- + (encoder sizeJumpLong: size)
- + size!

Item was changed:
+ ----- Method: BraceNode>>elements (in category 'code generation') -----
- ----- Method: BraceNode>>elements (in category 'code generation (closures)') -----
  elements
  ^elements!

Item was changed:
  ----- Method: BraceNode>>emitCodeForValue:encoder: (in category 'code generation') -----
  emitCodeForValue: stack encoder: encoder
+ "Hack; when sizing we have no way of knowing how much stack space is available."
+ elements size <= self maxElementsForConsArray ifTrue:
-
- (encoder supportsClosureOpcodes
- "Hack; we have no way of knowing how much stack space is available"
- and: [elements size <= self maxElementsForConsArray]) ifTrue:
  [elements do: [:node| node emitCodeForValue: stack encoder: encoder].
  encoder genPushConsArray: elements size.
  stack
  pop: elements size;
  push: 1.
  ^self].
  ^emitNode emitCodeForValue: stack encoder: encoder!

Item was changed:
+ ----- Method: BraceNode>>maxElementsForConsArray (in category 'code generation') -----
- ----- Method: BraceNode>>maxElementsForConsArray (in category 'code generation (closures)') -----
  maxElementsForConsArray
  "Hack; we have no way of knowing how much stack space is available during sizing"
  ^8!

Item was changed:
  ----- Method: BraceNode>>sizeCodeForValue: (in category 'code generation') -----
  sizeCodeForValue: encoder
 
+ "Hack; we have no way of knowing how much stack space is available."
+ elements size <= self maxElementsForConsArray ifTrue:
- (encoder supportsClosureOpcodes
- "Hack; we have no way of knowing how much stack space is available"
- and: [elements size <= self maxElementsForConsArray]) ifTrue:
  [^(elements inject: 0 into: [:sum :node| sum + (node sizeCodeForValue: encoder)])
   + (encoder sizePushConsArray: elements size)].
+ "Long form: (Array braceStream: N) nextPut: a; nextPut: b; ...; braceArray"
+ emitNode := CascadeNode new
- emitNode := elements size <= 4
- ifTrue: ["Short form: Array braceWith: a with: b ... "
- MessageNode new
- receiver: (encoder encodeVariable: #Array)
- selector: (self selectorForShortForm: elements size)
- arguments: elements precedence: 3 from: encoder]
- ifFalse: ["Long form: (Array braceStream: N) nextPut: a; nextPut: b; ...; braceArray"
- CascadeNode new
  receiver: (MessageNode new
  receiver: (encoder encodeVariable: #Array)
  selector: #braceStream:
+ arguments: {encoder encodeLiteral: elements size}
- arguments: (Array with: (encoder encodeLiteral: elements size))
  precedence: 3 from: encoder)
+ messages: ((elements collect: [:elt |
+ MessageNode new
+ receiver: nil
+ selector: #nextPut:
+ arguments: {elt}
+ precedence: 3
+ from: encoder])
+ copyWith: (MessageNode new
+ receiver: nil
+ selector: #braceArray
+ arguments: #()
+ precedence: 1
+ from: encoder)).
- messages: ((elements collect: [:elt | MessageNode new receiver: nil
- selector: #nextPut:
- arguments: (Array with: elt)
- precedence: 3 from: encoder])
- copyWith: (MessageNode new receiver: nil
- selector: #braceArray
- arguments: (Array new)
- precedence: 1 from: encoder))].
  ^emitNode sizeCodeForValue: encoder!

Item was changed:
  ----- Method: BytecodeEncoder>>bindBlockArg:within: (in category 'temps') -----
  bindBlockArg: name within: aBlockNode
- "Read the comment in the superclass's method.
- If we have closures we should check the argument
- count against the block, not the method.
-
- (Note that this isn't entirely adequate either since optimized blocks
- will slip through the cracks (their arguments (i.e. ifNotNil: [:expr|)
- are charged against their enclosing block, not themselves))."
  | nArgs |
- self supportsClosureOpcodes ifFalse:
- [^super bindBlockArg: name within: aBlockNode].
  (nArgs := aBlockNode nArgsSlot) isNil ifTrue:
  [aBlockNode nArgsSlot: (nArgs := 0)].
+ nArgs >= 15 ifTrue:
- nArgs  >= 15 ifTrue:
  [^self notify: 'Too many arguments'].
  aBlockNode nArgsSlot: nArgs + 1.
  ^(self bindTemp: name)
  beBlockArg;
  nowHasDef;
  nowHasRef;
  yourself!

Item was changed:
  ----- Method: BytecodeEncoder>>bindBlockTemp:within: (in category 'temps') -----
  bindBlockTemp: name within: aBlockNode
- "Read the comment in the superclass's bindBlockArg:within: method.
- If we have closures we should check the argument
- count against the block, not the method.
-
- (Note that this isn't entirely adequate either since optimized blocks
- will slip through the cracks (their arguments (i.e. ifNotNil: [:expr|)
- are charged against their enclosing block, not themselves))."
  | nArgs |
+ (nArgs := aBlockNode nArgsSlot) ifNil:
- self supportsClosureOpcodes ifFalse:
- [^super bindBlockTemp: name within: aBlockNode].
- (nArgs := aBlockNode nArgsSlot) isNil ifTrue:
  [aBlockNode nArgsSlot: (nArgs := 0)].
  nArgs >= (CompiledMethod fullFrameSize - 1) ifTrue:
  [^self notify: 'Too many temporaries'].
  aBlockNode nArgsSlot: nArgs + 1.
  ^self bindTemp: name!

Item was changed:
  ----- Method: BytecodeEncoder>>bindTemp: (in category 'temps') -----
  bindTemp: name
+ "Declare a temporary; error not if a field or class variable or out-of-scope temp."
- "Declare a temporary; error not if a field or class variable or out-of-scope temp.
- Read the comment in Encoder>>bindBlockArg:within: and subclass implementations."
- self supportsClosureOpcodes ifFalse:
- [^super bindTemp: name].
  scopeTable at: name ifPresent:
  [:node|
  "When non-interactive raise the error only if it is a duplicate"
  node isTemp
  ifTrue:[node scope >= 0 ifTrue:
  [^self notify: 'Name already used in this method']]
  ifFalse:[self warnAboutShadowed: name]].
  ^self reallyBind: name!

Item was changed:
  ----- Method: RemoteTempVectorNode>>addRemoteTemp:encoder: (in category 'code generation (closures)') -----
  addRemoteTemp: aTempVariableNode encoder: encoder
+ remoteTemps ifNil:
- remoteTemps isNil ifTrue:
  [remoteTemps := OrderedCollection new].
  remoteTemps addLast: aTempVariableNode.
  aTempVariableNode referenceScopesAndIndicesDo:
  [:scopeBlock "<BlockNode>" :location "<Integer>"|
+ self addReadWithin: scopeBlock at: location]!
- self addReadWithin: scopeBlock at: location].
- encoder supportsClosureOpcodes ifFalse:
- [encoder encodeLiteral: remoteTemps size.
- readNode := encoder encodeSelector: #at:.
- writeNode := encoder encodeSelector: #at:put:]!

Item was removed:
- ----- Method: RemoteTempVectorNode>>emitCodeForIndexOf:stack:encoder: (in category 'code generation (closures)') -----
- emitCodeForIndexOf: aTempVariableNode stack: stack encoder: encoder
- self assert: encoder supportsClosureOpcodes not.
- (encoder encodeLiteral: (remoteTemps indexOf: aTempVariableNode))
- emitCodeForValue: stack encoder: encoder!

Item was removed:
- ----- Method: RemoteTempVectorNode>>emitCodeForLoadFor:stack:encoder: (in category 'code generation (closures)') -----
- emitCodeForLoadFor: aTempVariableNode stack: stack encoder: encoder
- encoder supportsClosureOpcodes ifTrue:
- [^self].
- "Need to generate the first half of
- tempVector at: index put: expr
- i.e. the push of tempVector and index."
- super emitCodeForValue: stack encoder: encoder.
- self emitCodeForIndexOf: aTempVariableNode stack: stack encoder: encoder!

Item was changed:
+ ----- Method: RemoteTempVectorNode>>emitCodeForStoreInto:stack:encoder: (in category 'code generation') -----
- ----- Method: RemoteTempVectorNode>>emitCodeForStoreInto:stack:encoder: (in category 'code generation (closures)') -----
  emitCodeForStoreInto: aTempVariableNode stack: stack encoder: encoder
+ encoder
+ genStoreRemoteTemp: (remoteTemps indexOf: aTempVariableNode) - 1
+ inVectorAt: index!
- encoder supportsClosureOpcodes
- ifTrue:
- [encoder
- genStoreRemoteTemp: (remoteTemps indexOf: aTempVariableNode) - 1
- inVectorAt: index]
- ifFalse:
- [writeNode
- emitCode: stack
- args: 2
- encoder: encoder
- super: false]!

Item was changed:
+ ----- Method: RemoteTempVectorNode>>emitCodeForStorePopInto:stack:encoder: (in category 'code generation') -----
- ----- Method: RemoteTempVectorNode>>emitCodeForStorePopInto:stack:encoder: (in category 'code generation (closures)') -----
  emitCodeForStorePopInto: aTempVariableNode stack: stack encoder: encoder
+ encoder
+ genStorePopRemoteTemp: (remoteTemps indexOf: aTempVariableNode) - 1
+ inVectorAt: index.
- encoder supportsClosureOpcodes
- ifTrue:
- [encoder
- genStorePopRemoteTemp: (remoteTemps indexOf: aTempVariableNode) - 1
- inVectorAt: index]
- ifFalse:
- [self emitCodeForStoreInto: aTempVariableNode stack: stack encoder: encoder.
- encoder genPop].
  stack pop: 1!

Item was changed:
+ ----- Method: RemoteTempVectorNode>>emitCodeForValueOf:stack:encoder: (in category 'code generation') -----
- ----- Method: RemoteTempVectorNode>>emitCodeForValueOf:stack:encoder: (in category 'code generation (closures)') -----
  emitCodeForValueOf: aTempVariableNode stack: stack encoder: encoder
+ encoder
+ genPushRemoteTemp: (remoteTemps indexOf: aTempVariableNode) - 1
+ inVectorAt: index.
+ stack push: 1!
- encoder supportsClosureOpcodes
- ifTrue:
- [encoder
- genPushRemoteTemp: (remoteTemps indexOf: aTempVariableNode) - 1
- inVectorAt: index.
- stack push: 1]
- ifFalse:
- [self emitCodeForLoadFor: aTempVariableNode stack: stack encoder: encoder.
- readNode
- emitCode: stack
- args: 1
- encoder: encoder
- super: false]!

Item was changed:
+ ----- Method: RemoteTempVectorNode>>nodeToInitialize: (in category 'code generation') -----
- ----- Method: RemoteTempVectorNode>>nodeToInitialize: (in category 'code generation (closures)') -----
  nodeToInitialize: encoder
  ^AssignmentNode new
  variable: self
+ value: (NewArrayNode new numElements: remoteTemps size)!
- value: (encoder supportsClosureOpcodes
- ifTrue: [NewArrayNode new numElements: remoteTemps size]
- ifFalse:
- [MessageNode new
- receiver: (encoder encodeVariable: 'Array')
- selector: #new:
- arguments: (Array with: (encoder encodeLiteral: remoteTemps size))
- precedence: 3
- from: encoder])!

Item was changed:
+ ----- Method: RemoteTempVectorNode>>scope (in category 'code generation') -----
- ----- Method: RemoteTempVectorNode>>scope (in category 'code generation (closures)') -----
  scope
  "Answer scope of temporary variables.
  Currently only the following distinctions are made:
  0 outer level: args and user-declared temps
  1 block args and doLimiT temps
  -1 a block temp that is no longer active
  -2 a block temp that held limit of to:do:
  -3 an indirect temp vector"
  ^-3!

Item was removed:
- ----- Method: RemoteTempVectorNode>>sizeCodeForIndexOf:encoder: (in category 'code generation (closures)') -----
- sizeCodeForIndexOf: aTempVariableNode encoder: encoder
- self assert: encoder supportsClosureOpcodes not.
- ^(encoder encodeLiteral: (remoteTemps indexOf: aTempVariableNode)) sizeCodeForValue: encoder!

Item was removed:
- ----- Method: RemoteTempVectorNode>>sizeCodeForLoadFor:encoder: (in category 'code generation (closures)') -----
- sizeCodeForLoadFor: aTempVariableNode encoder: encoder
- encoder supportsClosureOpcodes ifTrue:
- [^0].
- "Need to size the first half of
- tempVector at: index put: expr
- i.e. the push of tempVector and index."
- ^(super sizeCodeForValue: encoder)
- + (self sizeCodeForIndexOf: aTempVariableNode encoder: encoder)!

Item was changed:
+ ----- Method: RemoteTempVectorNode>>sizeCodeForStoreInto:encoder: (in category 'code generation') -----
- ----- Method: RemoteTempVectorNode>>sizeCodeForStoreInto:encoder: (in category 'code generation (closures)') -----
  sizeCodeForStoreInto: aTempVariableNode encoder: encoder
+ ^encoder
+ sizeStoreRemoteTemp: (remoteTemps indexOf: aTempVariableNode) - 1
+ inVectorAt: index!
- encoder supportsClosureOpcodes ifTrue:
- [^encoder sizeStoreRemoteTemp: (remoteTemps indexOf: aTempVariableNode) - 1 inVectorAt: index].
- ^writeNode sizeCode: encoder args: 2 super: false!

Item was changed:
+ ----- Method: RemoteTempVectorNode>>sizeCodeForStorePopInto:encoder: (in category 'code generation') -----
- ----- Method: RemoteTempVectorNode>>sizeCodeForStorePopInto:encoder: (in category 'code generation (closures)') -----
  sizeCodeForStorePopInto: aTempVariableNode encoder: encoder
+ ^encoder
+ sizeStorePopRemoteTemp: (remoteTemps indexOf: aTempVariableNode) - 1
+ inVectorAt: index!
- encoder supportsClosureOpcodes ifTrue:
- [^encoder sizeStorePopRemoteTemp: (remoteTemps indexOf: aTempVariableNode) - 1 inVectorAt: index].
- ^(self sizeCodeForStoreInto: aTempVariableNode encoder: encoder)
- + encoder sizePop!

Item was changed:
+ ----- Method: RemoteTempVectorNode>>sizeCodeForValueOf:encoder: (in category 'code generation') -----
- ----- Method: RemoteTempVectorNode>>sizeCodeForValueOf:encoder: (in category 'code generation (closures)') -----
  sizeCodeForValueOf: aTempVariableNode encoder: encoder
+ ^encoder
+ sizePushRemoteTemp: (remoteTemps indexOf: aTempVariableNode) - 1
+ inVectorAt: index!
- encoder supportsClosureOpcodes ifTrue:
- [^encoder sizePushRemoteTemp: (remoteTemps indexOf: aTempVariableNode) - 1 inVectorAt: index].
- ^(self sizeCodeForValue: encoder)
- + (self sizeCodeForIndexOf: aTempVariableNode encoder: encoder)
- + (readNode sizeCode: encoder args: 1 super: false)!

Item was changed:
+ ----- Method: SpecialLiteralNode>>emitCodeForValue:encoder: (in category 'code generation') -----
- ----- Method: SpecialLiteralNode>>emitCodeForValue:encoder: (in category 'code generation (closures)') -----
  emitCodeForValue: stack encoder: encoder
  stack push: 1.
  encoder genPushSpecialLiteral: key!

Item was changed:
+ ----- Method: SpecialLiteralNode>>sizeCodeForValue: (in category 'code generation') -----
- ----- Method: SpecialLiteralNode>>sizeCodeForValue: (in category 'code generation (closures)') -----
  sizeCodeForValue: encoder
  ^encoder sizePushSpecialLiteral: key!

Item was removed:
- ----- Method: TempVariableNode>>emitCodeForLoad:forValue:encoder: (in category 'code generation') -----
- emitCodeForLoad: stack forValue: forValue encoder: encoder
- remoteNode ~~ nil ifTrue:
- [remoteNode emitCodeForLoadFor: self stack: stack encoder: encoder]!

Item was removed:
- ----- Method: TempVariableNode>>sizeCodeForLoad:forValue: (in category 'code generation') -----
- sizeCodeForLoad: encoder forValue: forValue
- ^remoteNode
- ifNil: [0]
- ifNotNil: [remoteNode sizeCodeForLoadFor: self encoder: encoder]!

Item was removed:
- ----- Method: VariableNode>>emitCodeForLoad:forValue:encoder: (in category 'code generation') -----
- emitCodeForLoad: stack forValue: forValue encoder: encoder
- "Do nothing"!