The document discusses reflective methods, which are a way to provide structural and behavioral reflection at the sub-method level in Smalltalk. Reflective methods use annotated abstract syntax trees (ASTs) that are compiled to bytecode on demand. This allows tools to access and modify the AST, enabling uses like pluggable type systems, invalidation of code, and partial behavioral reflection through hooksets. Demo examples are shown for code invalidation, assertions, coverage analysis, and behavior modification with Geppetto. Future work areas include optimizing the AST size and enabling contextual reifications.

1. The Reflectivity
Marcus Denker
with:
David Röthlisberger
Philippe Marschall
Nik Haldiman
Adrian Lienhard / Lukas Renggli
Eric Tanter
Stephane Ducasse
Oscar Nierstrasz
© Marcus Denker

2. Structural Reflection
> Structure modeled as objects
— e.g. Classes, methods
— Causally connected
> Uses:
— Development environments
— Language extensions and experiments
© Marcus Denker

3. Methods and Reflection
> Method are Objects
— e.g in Smalltalk
> No high-level model for sub-method elements
— Message sends
— Assignments
— Variable access
> Structural reflection stops at the granularity of methods
© Marcus Denker

4. Sub-Method Reflection
> Many tools work on sub method level
— Profiler, Refactoring Tool, Debugger, Type Checker
> Communication between tools needed
— example: Code coverage
> All tools use different representations
— Tools are harder to build
— Communication not possible
© Marcus Denker

5. Solution: Reflective Methods
> Annotated, persistent AST
> Bytecode generated on demand and cached
:ReflectiveMethod :CompiledMethod
annotation compiledMethod
#(12 13 45 38 98 128
annotation
reflectiveMethod 84 72 42 77 22 28 59
32 7 49 51 87 64)
Tools VM
© Marcus Denker

6. Reflectivity
> Implementation of Reflective Methods for Squeak
Smalltalk
> Smalltalk Compiler generates Reflective Methods
— Translated to Bytecode on demand
> Open Compiler: Plugins
— Generator plugin: called before code generation
– Transform a copy of the AST
— Analysis plugin: called after name analysis
© Marcus Denker

7. DEMO I
> Show invalidation of code
> Show assert Demo
© Marcus Denker

8. Reflective Methods: Annotations
> Source visible annotations
— extended Smalltalk syntax
(9 raisedTo: 10000) <:evaluateAtCompiletime:>
> Source invisible annotations
— Reflective API
— Can reference any object
> Every node can be annotated
> Semantics: Compiler Plugins
© Marcus Denker

9. Example: Pluggable Type-System
> Example for textual annotations
bitFromBoolean: aBoolean <:type: Boolean :>
^ (aBoolean ifTrue: [1] ifFalse: [0]) <:type: Integer :>
> Optional, pluggable type-system
> Types stored as annotations in the Reflective Methods
© Marcus Denker

10. Reflex: Partial Behavioral Reflection
> Hooksets: collection of operation occurrences
> Links
— Bind hooksets to metaobjects
— Define Protocol between base and meta
metaobject
> Goals
— Highly selective reification links activation
condition
— Flexiblel metalevel engineering
– Protocol specification hookset
– Cross-cutting hooksets
Tanter, OOPSLA03
© Marcus Denker

11. Links as Annotations
> Links can be annotations on the AST
Meta
Link
© Marcus Denker

12. Demo II: Geppetto
> Show Bounce Demo
> Show Coverage Demo
© Marcus Denker

13. Future Work
> Optimize Size of AST Representation
— Simpler AST
— AST Compression
> Contextual Reifications
— Context depended Links
> Beyond Text
— Store only AST (no text)
— Build text from annotated AST
© Marcus Denker