Pragmas.

`inlineJS:` processed as a pragma during compilation.

ASTInterpreter / ASTDebugger fail for inlineJS:,
this needs more work.

src/Compiler-AST.js

@@ -2081,7 +2081,7 @@ $globals.SendNode);
 
 
 
-$core.addClass("SequenceNode", $globals.ASTNode, ["temps", "scope"], "Compiler-AST");
+$core.addClass("SequenceNode", $globals.ASTNode, ["temps", "pragmas", "scope"], "Compiler-AST");
 //>>excludeStart("ide", pragmas.excludeIdeData);
 $globals.SequenceNode.comment="I represent an sequence node. A sequence represent a set of instructions inside the same scope (the method scope or a block scope).";
 //>>excludeEnd("ide");
@@ -2123,6 +2123,7 @@ $recv($1)._position_($self._position());
 $recv($1)._source_($self._source());
 $recv($1)._dagChildren_($self._dagChildren());
 $recv($1)._temps_($self._temps());
+$recv($1)._pragmas_($self._pragmas());
 return $recv($1)._yourself();
 //>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx1) {$ctx1.fill(self,"asBlockSequenceNode",{},$globals.SequenceNode)});
@@ -2130,10 +2131,10 @@ return $recv($1)._yourself();
 },
 //>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
-source: "asBlockSequenceNode\x0a\x09^ BlockSequenceNode new\x0a\x09\x09position: self position;\x0a\x09\x09source: self source;\x0a\x09\x09dagChildren: self dagChildren;\x0a\x09\x09temps: self temps;\x0a\x09\x09yourself",
+source: "asBlockSequenceNode\x0a\x09^ BlockSequenceNode new\x0a\x09\x09position: self position;\x0a\x09\x09source: self source;\x0a\x09\x09dagChildren: self dagChildren;\x0a\x09\x09temps: self temps;\x0a\x09\x09pragmas: self pragmas;\x0a\x09\x09yourself",
 referencedClasses: ["BlockSequenceNode"],
 //>>excludeEnd("ide");
-messageSends: ["position:", "new", "position", "source:", "source", "dagChildren:", "dagChildren", "temps:", "temps", "yourself"]
+messageSends: ["position:", "new", "position", "source:", "source", "dagChildren:", "dagChildren", "temps:", "temps", "pragmas:", "pragmas", "yourself"]
 }),
 $globals.SequenceNode);
 
@@ -2155,6 +2156,54 @@ messageSends: []
 }),
 $globals.SequenceNode);
 
+$core.addMethod(
+$core.method({
+selector: "pragmas",
+protocol: "accessing",
+fn: function (){
+var self=this,$self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) {
+//>>excludeEnd("ctx");
+var $1,$receiver;
+$1=$self["@pragmas"];
+if(($receiver = $1) == null || $receiver.a$nil){
+return [];
+} else {
+return $1;
+}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"pragmas",{},$globals.SequenceNode)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
+args: [],
+source: "pragmas\x0a\x09^ pragmas ifNil: [ #() ]",
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["ifNil:"]
+}),
+$globals.SequenceNode);
+
+$core.addMethod(
+$core.method({
+selector: "pragmas:",
+protocol: "accessing",
+fn: function (aCollection){
+var self=this,$self=this;
+$self["@pragmas"]=aCollection;
+return self;
+
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
+args: ["aCollection"],
+source: "pragmas: aCollection\x0a\x09pragmas := aCollection",
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
+}),
+$globals.SequenceNode);
+
 $core.addMethod(
 $core.method({
 selector: "scope",
@@ -2287,6 +2336,47 @@ messageSends: []
 }),
 $globals.BlockSequenceNode);
 
+$core.addMethod(
+$core.method({
+selector: "pragmas:",
+protocol: "visiting",
+fn: function (aCollection){
+var self=this,$self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) {
+//>>excludeEnd("ctx");
+var $1;
+$recv(aCollection)._ifNotEmpty_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
+return $self._error_("Block must have no pragmas.");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
+}));
+$1=(
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+$ctx1.supercall = true,
+//>>excludeEnd("ctx");
+($globals.BlockSequenceNode.superclass||$boot.nilAsClass).fn.prototype._pragmas_.apply($self, [aCollection]));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+$ctx1.supercall = false;
+//>>excludeEnd("ctx");;
+return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"pragmas:",{aCollection:aCollection},$globals.BlockSequenceNode)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
+args: ["aCollection"],
+source: "pragmas: aCollection\x0a\x09aCollection ifNotEmpty: [\x0a\x09\x09self error: 'Block must have no pragmas.' ].\x0a\x09^ super pragmas: aCollection",
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["ifNotEmpty:", "error:", "pragmas:"]
+}),
+$globals.BlockSequenceNode);
+
 
 
 $core.addClass("ValueNode", $globals.ASTNode, ["value"], "Compiler-AST");
@@ -3060,6 +3150,268 @@ messageSends: ["visitDagNode:"]
 $globals.NodeVisitor);
 
 
+
+$core.addClass("Pragmator", $globals.NodeVisitor, ["methodNode", "sequenceNode"], "Compiler-AST");
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$globals.Pragmator.comment="I am abstract superclass for pragma-processing transformer.\x0a\x0aMy subclasses should implement messages for each pragma\x0athey process. Pragma processing checks if a message is known\x0ato a class but not to its superclass. IOW, each and only those\x0apragmas are processed which are defined as methods in the subclass.\x0a\x0aThese messages can access sequence node in which\x0aa pragma occurred and its containing method node\x0aas `self sequenceNode` and `self methodNode`.\x0a\x0aSee `EarlyPragmator` for an example.";
+//>>excludeEnd("ide");
+$core.addMethod(
+$core.method({
+selector: "canProcessPragma:",
+protocol: "pragma processing",
+fn: function (aMessage){
+var self=this,$self=this;
+var selector;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) {
+//>>excludeEnd("ctx");
+selector=$recv(aMessage)._selector();
+return $recv($self._respondsTo_(selector))._and_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
+return $recv($recv($recv($self._class())._superclass())._canUnderstand_(selector))._not();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
+}));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"canProcessPragma:",{aMessage:aMessage,selector:selector},$globals.Pragmator)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
+args: ["aMessage"],
+source: "canProcessPragma: aMessage\x0a\x09| selector |\x0a\x09selector := aMessage selector.\x0a\x09^ (self respondsTo: selector) and: [\x0a\x09\x09(self class superclass canUnderstand: selector) not]",
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["selector", "and:", "respondsTo:", "not", "canUnderstand:", "superclass", "class"]
+}),
+$globals.Pragmator);
+
+$core.addMethod(
+$core.method({
+selector: "methodNode",
+protocol: "accessing",
+fn: function (){
+var self=this,$self=this;
+return $self["@methodNode"];
+
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
+args: [],
+source: "methodNode\x0a\x09^ methodNode",
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
+}),
+$globals.Pragmator);
+
+$core.addMethod(
+$core.method({
+selector: "methodNode:",
+protocol: "accessing",
+fn: function (anObject){
+var self=this,$self=this;
+$self["@methodNode"]=anObject;
+return self;
+
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
+args: ["anObject"],
+source: "methodNode: anObject\x0a\x09methodNode := anObject",
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
+}),
+$globals.Pragmator);
+
+$core.addMethod(
+$core.method({
+selector: "processPragma:",
+protocol: "pragma processing",
+fn: function (aMessage){
+var self=this,$self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) {
+//>>excludeEnd("ctx");
+var $1;
+$1=$self._canProcessPragma_(aMessage);
+if($core.assert($1)){
+return $recv(aMessage)._sendTo_(self);
+}
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"processPragma:",{aMessage:aMessage},$globals.Pragmator)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
+args: ["aMessage"],
+source: "processPragma: aMessage\x0a\x09(self canProcessPragma: aMessage) ifTrue: [\x0a\x09\x09^ aMessage sendTo: self ]",
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["ifTrue:", "canProcessPragma:", "sendTo:"]
+}),
+$globals.Pragmator);
+
+$core.addMethod(
+$core.method({
+selector: "sequenceNode",
+protocol: "accessing",
+fn: function (){
+var self=this,$self=this;
+return $self["@sequenceNode"];
+
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
+args: [],
+source: "sequenceNode\x0a\x09^ sequenceNode",
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
+}),
+$globals.Pragmator);
+
+$core.addMethod(
+$core.method({
+selector: "sequenceNode:",
+protocol: "accessing",
+fn: function (anObject){
+var self=this,$self=this;
+$self["@sequenceNode"]=anObject;
+return self;
+
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
+args: ["anObject"],
+source: "sequenceNode: anObject\x0a\x09sequenceNode := anObject",
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
+}),
+$globals.Pragmator);
+
+$core.addMethod(
+$core.method({
+selector: "visitMethodNode:",
+protocol: "pragma processing",
+fn: function (aNode){
+var self=this,$self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) {
+//>>excludeEnd("ctx");
+var $1;
+$self._methodNode_(aNode);
+$1=(
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+$ctx1.supercall = true,
+//>>excludeEnd("ctx");
+($globals.Pragmator.superclass||$boot.nilAsClass).fn.prototype._visitMethodNode_.apply($self, [aNode]));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+$ctx1.supercall = false;
+//>>excludeEnd("ctx");;
+return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"visitMethodNode:",{aNode:aNode},$globals.Pragmator)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
+args: ["aNode"],
+source: "visitMethodNode: aNode\x0a\x09self methodNode: aNode.\x0a\x09^ super visitMethodNode: aNode",
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["methodNode:", "visitMethodNode:"]
+}),
+$globals.Pragmator);
+
+$core.addMethod(
+$core.method({
+selector: "visitSequenceNode:",
+protocol: "pragma processing",
+fn: function (aNode){
+var self=this,$self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) {
+//>>excludeEnd("ctx");
+var $1;
+$self._sequenceNode_(aNode);
+$recv($recv(aNode)._pragmas())._do_((function(each){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
+return $self._processPragma_(each);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)});
+//>>excludeEnd("ctx");
+}));
+$1=(
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+$ctx1.supercall = true,
+//>>excludeEnd("ctx");
+($globals.Pragmator.superclass||$boot.nilAsClass).fn.prototype._visitSequenceNode_.apply($self, [aNode]));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+$ctx1.supercall = false;
+//>>excludeEnd("ctx");;
+return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"visitSequenceNode:",{aNode:aNode},$globals.Pragmator)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
+args: ["aNode"],
+source: "visitSequenceNode: aNode\x0a\x09self sequenceNode: aNode.\x0a\x09aNode pragmas do: [ :each | self processPragma: each ].\x0a\x09^ super visitSequenceNode: aNode",
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["sequenceNode:", "do:", "pragmas", "processPragma:", "visitSequenceNode:"]
+}),
+$globals.Pragmator);
+
+
+
+$core.addClass("EarlyPragmator", $globals.Pragmator, [], "Compiler-AST");
+$core.addMethod(
+$core.method({
+selector: "inlineJS:",
+protocol: "pragmas",
+fn: function (aString){
+var self=this,$self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) {
+//>>excludeEnd("ctx");
+var $2,$1,$3,$5,$4;
+$2=$self._sequenceNode();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+$ctx1.sendIdx["sequenceNode"]=1;
+//>>excludeEnd("ctx");
+$1=$recv($2)._dagChildren();
+$recv($1)._ifNotEmpty_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
+return $self._error_("inlineJS: does not allow smalltalk statements");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
+}));
+$3=$self._sequenceNode();
+$5=$recv($globals.JSStatementNode)._new();
+$recv($5)._source_(aString);
+$4=$recv($5)._yourself();
+$recv($3)._addDagChild_($4);
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"inlineJS:",{aString:aString},$globals.EarlyPragmator)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
+args: ["aString"],
+source: "inlineJS: aString\x0a\x09self sequenceNode dagChildren ifNotEmpty: [\x0a\x09\x09self error: 'inlineJS: does not allow smalltalk statements' ].\x0a\x09self sequenceNode addDagChild: (\x0a\x09\x09JSStatementNode new\x0a\x09\x09\x09source: aString;\x0a\x09\x09\x09yourself)",
+referencedClasses: ["JSStatementNode"],
+//>>excludeEnd("ide");
+messageSends: ["ifNotEmpty:", "dagChildren", "sequenceNode", "error:", "addDagChild:", "source:", "new", "yourself"]
+}),
+$globals.EarlyPragmator);
+
+
 $core.addMethod(
 $core.method({
 selector: "ast",

src/Compiler-AST.st

@@ -516,13 +516,21 @@ acceptDagVisitor: aVisitor
 ! !
 
 ASTNode subclass: #SequenceNode
-	instanceVariableNames: 'temps scope'
+	instanceVariableNames: 'temps pragmas scope'
 	package: 'Compiler-AST'!
 !SequenceNode commentStamp!
 I represent an sequence node. A sequence represent a set of instructions inside the same scope (the method scope or a block scope).!
 
 !SequenceNode methodsFor: 'accessing'!
 
+pragmas
+	^ pragmas ifNil: [ #() ]
+!
+
+pragmas: aCollection
+	pragmas := aCollection
+!
+
 scope
 	^ scope
 !
@@ -547,6 +555,7 @@ asBlockSequenceNode
 		source: self source;
 		dagChildren: self dagChildren;
 		temps: self temps;
+		pragmas: self pragmas;
 		yourself
 ! !
 
@@ -578,6 +587,12 @@ isBlockSequenceNode
 
 acceptDagVisitor: aVisitor
 	^ aVisitor visitBlockSequenceNode: self
+!
+
+pragmas: aCollection
+	aCollection ifNotEmpty: [
+		self error: 'Block must have no pragmas.' ].
+	^ super pragmas: aCollection
 ! !
 
 ASTNode subclass: #ValueNode
@@ -757,6 +772,81 @@ visitVariableNode: aNode
 	^ self visitDagNode: aNode
 ! !
 
+NodeVisitor subclass: #Pragmator
+	instanceVariableNames: 'methodNode sequenceNode'
+	package: 'Compiler-AST'!
+!Pragmator commentStamp!
+I am abstract superclass for pragma-processing transformer.
+
+My subclasses should implement messages for each pragma
+they process. Pragma processing checks if a message is known
+to a class but not to its superclass. IOW, each and only those
+pragmas are processed which are defined as methods in the subclass.
+
+These messages can access sequence node in which
+a pragma occurred and its containing method node
+as `self sequenceNode` and `self methodNode`.
+
+See `EarlyPragmator` for an example.!
+
+!Pragmator methodsFor: 'accessing'!
+
+methodNode
+	^ methodNode
+!
+
+methodNode: anObject
+	methodNode := anObject
+!
+
+sequenceNode
+	^ sequenceNode
+!
+
+sequenceNode: anObject
+	sequenceNode := anObject
+! !
+
+!Pragmator methodsFor: 'pragma processing'!
+
+canProcessPragma: aMessage
+	| selector |
+	selector := aMessage selector.
+	^ (self respondsTo: selector) and: [
+		(self class superclass canUnderstand: selector) not]
+!
+
+processPragma: aMessage
+	(self canProcessPragma: aMessage) ifTrue: [
+		^ aMessage sendTo: self ]
+!
+
+visitMethodNode: aNode
+	self methodNode: aNode.
+	^ super visitMethodNode: aNode
+!
+
+visitSequenceNode: aNode
+	self sequenceNode: aNode.
+	aNode pragmas do: [ :each | self processPragma: each ].
+	^ super visitSequenceNode: aNode
+! !
+
+Pragmator subclass: #EarlyPragmator
+	instanceVariableNames: ''
+	package: 'Compiler-AST'!
+
+!EarlyPragmator methodsFor: 'pragmas'!
+
+inlineJS: aString
+	self sequenceNode dagChildren ifNotEmpty: [
+		self error: 'inlineJS: does not allow smalltalk statements' ].
+	self sequenceNode addDagChild: (
+		JSStatementNode new
+			source: aString;
+			yourself)
+! !
+
 !CompiledMethod methodsFor: '*Compiler-AST'!
 
 ast

src/Compiler-Core.js

@@ -331,14 +331,21 @@ var $1,$2,$receiver;
 $1=$self["@transformersDictionary"];
 if(($receiver = $1) == null || $receiver.a$nil){
 $2=$recv($globals.Dictionary)._new();
-$recv($2)._at_put_("2000-semantic",$self._semanticAnalyzer());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+$ctx1.sendIdx["new"]=1;
+//>>excludeEnd("ctx");
+$recv($2)._at_put_("1000-earlyPragmas",$recv($globals.EarlyPragmator)._new());
 //>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["at:put:"]=1;
 //>>excludeEnd("ctx");
-$recv($2)._at_put_("5000-astToIr",$self._translator());
+$recv($2)._at_put_("2000-semantic",$self._semanticAnalyzer());
 //>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["at:put:"]=2;
 //>>excludeEnd("ctx");
+$recv($2)._at_put_("5000-astToIr",$self._translator());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+$ctx1.sendIdx["at:put:"]=3;
+//>>excludeEnd("ctx");
 $recv($2)._at_put_("8000-irToJs",$self._irTranslator());
 $self["@transformersDictionary"]=$recv($2)._yourself();
 return $self["@transformersDictionary"];
@@ -351,8 +358,8 @@ return $1;
 },
 //>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
-source: "transformersDictionary\x0a\x09^ transformersDictionary ifNil: [ transformersDictionary := Dictionary new\x0a\x09\x09at: '2000-semantic' put: self semanticAnalyzer;\x0a\x09\x09at: '5000-astToIr' put: self translator;\x0a\x09\x09at: '8000-irToJs' put: self irTranslator;\x0a\x09\x09yourself ]",
-referencedClasses: ["Dictionary"],
+source: "transformersDictionary\x0a\x09^ transformersDictionary ifNil: [ transformersDictionary := Dictionary new\x0a\x09\x09at: '1000-earlyPragmas' put: EarlyPragmator new;\x0a\x09\x09at: '2000-semantic' put: self semanticAnalyzer;\x0a\x09\x09at: '5000-astToIr' put: self translator;\x0a\x09\x09at: '8000-irToJs' put: self irTranslator;\x0a\x09\x09yourself ]",
+referencedClasses: ["Dictionary", "EarlyPragmator"],
 //>>excludeEnd("ide");
 messageSends: ["ifNil:", "at:put:", "new", "semanticAnalyzer", "translator", "irTranslator", "yourself"]
 }),

src/Compiler-Core.st

@@ -80,6 +80,7 @@ semanticAnalyzer
 
 transformersDictionary
 	^ transformersDictionary ifNil: [ transformersDictionary := Dictionary new
+		at: '1000-earlyPragmas' put: EarlyPragmator new;
 		at: '2000-semantic' put: self semanticAnalyzer;
 		at: '5000-astToIr' put: self translator;
 		at: '8000-irToJs' put: self irTranslator;

support/parser.pegjs

@@ -143,7 +143,7 @@ wsBinaryPattern = ws selector:binarySelector ws arg:identifier {
 
 wsUnaryPattern = ws selector:unarySelector {return [selector, []];}
 
-expression = assignment / cascade / keywordSend / jsStatement
+expression = assignment / cascade / keywordSend
 
 wsExpressionsRest = someDotsWs expression:expression {
 	return expression;
@@ -153,6 +153,25 @@ wsExpressions = maybeDotsWs first:expression others:wsExpressionsRest* {
 	return [first].concat(others);
 }
 
+wsUnaryPragmaMessage = ws selector:unarySelector !':' {
+	return $globals.Message._selector_arguments_(selector, []);
+}
+
+wsKeywordPragmaMessage =
+	pairs:(ws key:keyword ws arg:parseTimeLiteral {return {key:key, arg:arg};})+ {
+		var selector = '';
+		var args = [];
+		for(var i = 0; i < pairs.length; i++) {
+			selector += pairs[i].key;
+			args.push(pairs[i].arg._value());
+		}
+		return $globals.Message._selector_arguments_(selector, args)
+	}
+
+wsPragmaMessage = wsUnaryPragmaMessage / wsKeywordPragmaMessage
+
+wsPragmas = items:(ws '<' message:wsPragmaMessage ws '>' {return message;})*
+
 assignment = variable:variable ws ':=' ws expression:expression {
 	return $globals.AssignmentNode._new()
 		._location_(location())
@@ -190,11 +209,12 @@ wsStatements =
 	} /
 	expressions:wsExpressions? {return expressions || [];}
 
-wsSequenceWs = ws temps:temps? statements:wsStatements? maybeDotsWs {
+wsSequenceWs = aPragmas:wsPragmas? ws temps:temps? zPragmas:wsPragmas? statements:wsStatements? maybeDotsWs {
 	return $globals.SequenceNode._new()
 		._location_(location())
 		._source_(text())
 		._temps_(temps || [])
+		._pragmas_((aPragmas || []).concat(zPragmas || []))
 		._dagChildren_(statements || []);
 }
 
@@ -262,12 +282,6 @@ cascade =
 			._dagChildren_(messages);
 	}
 
-jsStatement = '<' ws 'inlineJS:' ws val:rawString ws '>' {
-	return $globals.JSStatementNode._new()
-		._location_(location())
-		._source_(val)
-}
-
 method =
 	pattern:(wsKeywordPattern / wsBinaryPattern / wsUnaryPattern)
 	sequence:wsSequenceWs {