Recompile

src/Benchfib.js

@@ -12,15 +12,22 @@ protocol: 'not yet classified',
 fn: function (){
 var self=this;
 var result;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 result=(0)._tinyBenchmarks();
 _st(console)._log_("0 tinyBenchmarks => ".__comma(result));
-return self}, function($ctx1) {$ctx1.fill(self,"main",{result:result},globals.Benchfib.klass)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"main",{result:result},globals.Benchfib.klass)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["tinyBenchmarks", "log:", ","],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "main\x0a\x0a\x09| result |\x0a\x09result := 0 tinyBenchmarks.\x0a\x09console log: '0 tinyBenchmarks => ' , result",
-messageSends: ["tinyBenchmarks", "log:", ","],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Benchfib.klass);
 
@@ -30,27 +37,39 @@ selector: "benchFib",
 protocol: '*Benchfib',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $2,$5,$4,$3,$1;
 $2=self.__lt((2));
 if(smalltalk.assert($2)){
 $1=(1);
 } else {
 $5=self.__minus((1));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["-"]=1;
+//>>excludeEnd("ctx");
 $4=_st($5)._benchFib();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["benchFib"]=1;
+//>>excludeEnd("ctx");
 $3=_st($4).__plus(_st(self.__minus((2)))._benchFib());
 $1=_st($3).__plus((1));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["+"]=1;
+//>>excludeEnd("ctx");
 };
 return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx1) {$ctx1.fill(self,"benchFib",{},globals.Number)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["ifTrue:ifFalse:", "<", "+", "benchFib", "-"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "benchFib\x0a\x09\x22Handy send-heavy benchmark\x22\x0a\x09\x22(result // seconds to run) = approx calls per second\x22\x0a\x09\x22\x09| r t |\x0a\x09\x09t := Time millisecondsToRun: [r := 26 benchFib].\x0a\x09\x09(r * 1000) // t\x22\x0a\x09\x22138000 on a Mac 8100/100\x22\x0a\x09^ self < 2\x0a\x09\x09ifTrue: [1]\x0a\x09\x09ifFalse: [(self-1) benchFib + (self-2) benchFib + 1]",
-messageSends: ["ifTrue:ifFalse:", "<", "+", "benchFib", "-"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Number);
 
@@ -62,58 +81,92 @@ fn: function (){
 var self=this;
 var size,flags,prime,k,count;
 function $Array(){return globals.Array||(typeof Array=="undefined"?nil:Array)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$2;
 size=(8190);
 (1)._to_do_(self,(function(iter){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 count=(0);
 count;
 flags=_st($Array())._new();
 flags;
 _st(size)._timesRepeat_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx3) {
+//>>excludeEnd("ctx");
 return _st(flags)._add_(true);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)});
+//>>excludeEnd("ctx");
 }));
 return (1)._to_do_(size,(function(i){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx3) {
+//>>excludeEnd("ctx");
 $1=_st(flags)._at_(i);
 if(smalltalk.assert($1)){
 prime=_st(i).__plus((1));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx3.sendIdx["+"]=1;
+//>>excludeEnd("ctx");
 prime;
 k=_st(i).__plus(prime);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx3.sendIdx["+"]=2;
+//>>excludeEnd("ctx");
 k;
 _st((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx4) {
+//>>excludeEnd("ctx");
 return _st(k).__lt_eq(size);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx4) {$ctx4.fillBlock({},$ctx3,5)});
+//>>excludeEnd("ctx");
 }))._whileTrue_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx4) {
+//>>excludeEnd("ctx");
 _st(flags)._at_put_(k,false);
 k=_st(k).__plus(prime);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx4.sendIdx["+"]=3;
+//>>excludeEnd("ctx");
 return k;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx4) {$ctx4.fillBlock({},$ctx3,6)});
+//>>excludeEnd("ctx");
 }));
 count=_st(count).__plus((1));
 return count;
 };
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx3) {$ctx3.fillBlock({i:i},$ctx2,3)});
+//>>excludeEnd("ctx");
 }));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({iter:iter},$ctx1,1)});
+//>>excludeEnd("ctx");
 }));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["to:do:"]=1;
+//>>excludeEnd("ctx");
 $2=count;
 return $2;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx1) {$ctx1.fill(self,"benchmark",{size:size,flags:flags,prime:prime,k:k,count:count},globals.Number)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["to:do:", "new", "timesRepeat:", "add:", "ifTrue:", "at:", "+", "whileTrue:", "<=", "at:put:"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "benchmark\x0a\x09\x22Handy bytecode-heavy benchmark\x22\x0a\x09\x22(500000 // time to run) = approx bytecodes per second\x22\x0a\x09\x225000000 // (Time millisecondsToRun: [10 benchmark]) * 1000\x22\x0a\x09\x223059000 on a Mac 8100/100\x22\x0a\x09| size flags prime k count |\x0a\x09size := 8190.\x0a\x091 to: self do:\x0a\x09\x09[:iter |\x0a\x09\x09count := 0.\x0a\x09\x09flags := Array new.\x0a\x09\x09size timesRepeat: [ flags add: true].\x0a\x09\x091 to: size do:\x0a\x09\x09\x09[:i | (flags at: i) ifTrue:\x0a\x09\x09\x09\x09[prime := i+1.\x0a\x09\x09\x09\x09k := i + prime.\x0a\x09\x09\x09\x09[k <= size] whileTrue:\x0a\x09\x09\x09\x09\x09[flags at: k put: false.\x0a\x09\x09\x09\x09\x09k := k + prime].\x0a\x09\x09\x09\x09count := count + 1]]].\x0a\x09^ count",
-messageSends: ["to:do:", "new", "timesRepeat:", "add:", "ifTrue:", "at:", "+", "whileTrue:", "<=", "at:put:"],
 referencedClasses: ["Array"]
+//>>excludeEnd("ide");
 }),
 globals.Number);
 
@@ -123,17 +176,24 @@ selector: "jsbenchFib",
 protocol: '*Benchfib',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 if (this < 2) {
 return 1;
 } else {
 return (this-1)._jsbenchFib() + (this-2)._jsbenchFib() + 1;};
-return self}, function($ctx1) {$ctx1.fill(self,"jsbenchFib",{},globals.Number)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"jsbenchFib",{},globals.Number)});
+//>>excludeEnd("ctx");
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "jsbenchFib\x0a\x0a\x09<if (this < 2) {\x0areturn 1;\x0a} else {\x0areturn (this-1)._jsbenchFib() + (this-2)._jsbenchFib() + 1;}>",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Number);
 
@@ -143,7 +203,9 @@ selector: "jsbenchmark",
 protocol: '*Benchfib',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 
 var size = 8190;
 var count;
@@ -166,12 +228,17 @@ for (var z=0;z<this;z++) {
 	}
 }
 return count;
-return self}, function($ctx1) {$ctx1.fill(self,"jsbenchmark",{},globals.Number)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"jsbenchmark",{},globals.Number)});
+//>>excludeEnd("ctx");
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "jsbenchmark\x0a\x0a<\x0avar size = 8190;\x0avar count;\x0afor (var z=0;z<this;z++) {\x0a\x09count = 0;\x0a\x09var flags = new Array();\x0a\x09for (var p=0; p<size; p++) {\x0a\x09flags[p] = true;\x0a\x09}\x0a\x09for (var i=1;i<=size;i++) {\x0a\x09\x09if (flags[i-1]) {\x0a\x09\x09\x09var prime = i+1;\x0a\x09\x09\x09var k = i + prime;\x0a\x09\x09\x09while (k <= size) {\x0a\x09\x09\x09\x09flags[k-1] = false;\x0a\x09\x09\x09\x09k = k + prime;\x0a\x09\x09\x09}\x0a\x09\x09\x09count = count + 1;\x0a\x09\x09}\x0a\x09}\x0a}\x0areturn count>",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Number);
 
@@ -183,67 +250,117 @@ fn: function (){
 var self=this;
 var t1,t2,r,n1,n2;
 function $Date(){return globals.Date||(typeof Date=="undefined"?nil:Date)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $7,$6,$5,$4,$3,$2,$1;
 n1=(1);
 _st((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 t1=_st($Date())._millisecondsToRun_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx3) {
+//>>excludeEnd("ctx");
 return _st(n1)._jsbenchmark();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)});
+//>>excludeEnd("ctx");
 }));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["millisecondsToRun:"]=1;
+//>>excludeEnd("ctx");
 t1;
 return _st(t1).__lt((1000));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["<"]=1;
+//>>excludeEnd("ctx");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
 }))._whileTrue_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 n1=_st(n1).__star((2));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["*"]=1;
+//>>excludeEnd("ctx");
 return n1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,3)});
+//>>excludeEnd("ctx");
 }));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["whileTrue:"]=1;
+//>>excludeEnd("ctx");
 n2=(28);
 _st((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 t2=_st($Date())._millisecondsToRun_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx3) {
+//>>excludeEnd("ctx");
 r=_st(n2)._jsbenchFib();
 return r;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx3) {$ctx3.fillBlock({},$ctx2,5)});
+//>>excludeEnd("ctx");
 }));
 t2;
 return _st(t2).__lt((1000));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,4)});
+//>>excludeEnd("ctx");
 }))._whileTrue_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 n2=_st(n2).__plus((1));
 return n2;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,6)});
+//>>excludeEnd("ctx");
 }));
 $7=_st(n1).__star((500000));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["*"]=3;
+//>>excludeEnd("ctx");
 $6=_st($7).__star((1000));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["*"]=2;
+//>>excludeEnd("ctx");
 $5=_st($6).__slash(t1);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["/"]=1;
+//>>excludeEnd("ctx");
 $4=_st($5)._printString();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["printString"]=1;
+//>>excludeEnd("ctx");
 $3=_st($4).__comma(" bytecodes/sec; ");
 $2=_st($3).__comma(_st(_st(_st(r).__star((1000))).__slash(t2))._printString());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx[","]=2;
+//>>excludeEnd("ctx");
 $1=_st($2).__comma(" sends/sec");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx[","]=1;
+//>>excludeEnd("ctx");
 return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx1) {$ctx1.fill(self,"jstinyBenchmarks",{t1:t1,t2:t2,r:r,n1:n1,n2:n2},globals.Number)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["whileTrue:", "millisecondsToRun:", "jsbenchmark", "<", "*", "jsbenchFib", "+", ",", "printString", "/"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "jstinyBenchmarks\x0a\x09\x220 jstinyBenchmarks\x22\x0a\x0a\x09| t1 t2 r n1 n2 |\x0a\x09n1 := 1.\x0a\x09[t1 := Date millisecondsToRun: [n1 jsbenchmark].\x0a\x09t1 < 1000] whileTrue:[n1 := n1 * 2]. \x22Note: #benchmark's runtime is about O(n)\x22\x0a\x0a\x09n2 := 28.\x0a\x09[t2 := Date millisecondsToRun: [r := n2 jsbenchFib].\x0a\x09t2 < 1000] whileTrue:[n2 := n2 + 1].\x0a\x09\x22Note: #jsbenchFib's runtime is about O(k^n),\x0a\x09\x09where k is the golden number = (1 + 5 sqrt) / 2 = 1.618....\x22\x0a\x0a\x09^ ((n1 * 500000 * 1000) / t1) printString, ' bytecodes/sec; ',\x0a\x09\x09((r * 1000) / t2) printString, ' sends/sec'",
-messageSends: ["whileTrue:", "millisecondsToRun:", "jsbenchmark", "<", "*", "jsbenchFib", "+", ",", "printString", "/"],
 referencedClasses: ["Date"]
+//>>excludeEnd("ide");
 }),
 globals.Number);
 
@@ -255,67 +372,117 @@ fn: function (){
 var self=this;
 var t1,t2,r,n1,n2;
 function $Date(){return globals.Date||(typeof Date=="undefined"?nil:Date)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $7,$6,$5,$4,$3,$2,$1;
 n1=(1);
 _st((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 t1=_st($Date())._millisecondsToRun_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx3) {
+//>>excludeEnd("ctx");
 return _st(n1)._benchmark();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)});
+//>>excludeEnd("ctx");
 }));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["millisecondsToRun:"]=1;
+//>>excludeEnd("ctx");
 t1;
 return _st(t1).__lt((1000));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["<"]=1;
+//>>excludeEnd("ctx");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
 }))._whileTrue_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 n1=_st(n1).__star((2));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["*"]=1;
+//>>excludeEnd("ctx");
 return n1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,3)});
+//>>excludeEnd("ctx");
 }));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["whileTrue:"]=1;
+//>>excludeEnd("ctx");
 n2=(16);
 _st((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 t2=_st($Date())._millisecondsToRun_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx3) {
+//>>excludeEnd("ctx");
 r=_st(n2)._benchFib();
 return r;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx3) {$ctx3.fillBlock({},$ctx2,5)});
+//>>excludeEnd("ctx");
 }));
 t2;
 return _st(t2).__lt((1000));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,4)});
+//>>excludeEnd("ctx");
 }))._whileTrue_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 n2=_st(n2).__plus((1));
 return n2;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,6)});
+//>>excludeEnd("ctx");
 }));
 $7=_st(n1).__star((500000));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["*"]=3;
+//>>excludeEnd("ctx");
 $6=_st($7).__star((1000));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["*"]=2;
+//>>excludeEnd("ctx");
 $5=_st($6).__slash(t1);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["/"]=1;
+//>>excludeEnd("ctx");
 $4=_st($5)._printString();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["printString"]=1;
+//>>excludeEnd("ctx");
 $3=_st($4).__comma(" bytecodes/sec; ");
 $2=_st($3).__comma(_st(_st(_st(r).__star((1000))).__slash(t2))._printString());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx[","]=2;
+//>>excludeEnd("ctx");
 $1=_st($2).__comma(" sends/sec");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx[","]=1;
+//>>excludeEnd("ctx");
 return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx1) {$ctx1.fill(self,"tinyBenchmarks",{t1:t1,t2:t2,r:r,n1:n1,n2:n2},globals.Number)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["whileTrue:", "millisecondsToRun:", "benchmark", "<", "*", "benchFib", "+", ",", "printString", "/"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "tinyBenchmarks\x0a\x09\x22Report the results of running the two tiny Squeak benchmarks.\x0a\x09ar 9/10/1999: Adjusted to run at least 1 sec to get more stable results\x22\x0a\x09\x220 tinyBenchmarks\x22\x0a\x09\x22On a 292 MHz G3 Mac: 22727272 bytecodes/sec; 984169 sends/sec\x22\x0a\x09\x22On a 400 MHz PII/Win98: 18028169 bytecodes/sec; 1081272 sends/sec\x22\x0a\x09| t1 t2 r n1 n2 |\x0a\x09n1 := 1.\x0a\x09[t1 := Date millisecondsToRun: [n1 benchmark].\x0a\x09t1 < 1000] whileTrue:[n1 := n1 * 2]. \x22Note: #benchmark's runtime is about O(n)\x22\x0a\x0a\x09n2 := 16.\x0a\x09[t2 := Date millisecondsToRun: [r := n2 benchFib].\x0a\x09t2 < 1000] whileTrue:[n2 := n2 + 1].\x0a\x09\x22Note: #benchFib's runtime is about O(k^n),\x0a\x09\x09where k is the golden number = (1 + 5 sqrt) / 2 = 1.618....\x22\x0a\x0a\x09^ ((n1 * 500000 * 1000) / t1) printString, ' bytecodes/sec; ',\x0a\x09\x09((r * 1000) / t2) printString, ' sends/sec'",
-messageSends: ["whileTrue:", "millisecondsToRun:", "benchmark", "<", "*", "benchFib", "+", ",", "printString", "/"],
 referencedClasses: ["Date"]
+//>>excludeEnd("ide");
 }),
 globals.Number);
 

src/Compiler-Exceptions.js

@@ -4,39 +4,55 @@ smalltalk.addPackage('Compiler-Exceptions');
 smalltalk.packages["Compiler-Exceptions"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
 smalltalk.addClass('CompilerError', globals.Error, [], 'Compiler-Exceptions');
+//>>excludeStart("ide", pragmas.excludeIdeData);
 globals.CompilerError.comment="I am the common superclass of all compiling errors.";
+//>>excludeEnd("ide");
 
 
 smalltalk.addClass('ParseError', globals.CompilerError, [], 'Compiler-Exceptions');
+//>>excludeStart("ide", pragmas.excludeIdeData);
 globals.ParseError.comment="Instance of ParseError are signaled on any parsing error.\x0aSee `Smalltalk >> #parse:`";
+//>>excludeEnd("ide");
 
 
 smalltalk.addClass('SemanticError', globals.CompilerError, [], 'Compiler-Exceptions');
+//>>excludeStart("ide", pragmas.excludeIdeData);
 globals.SemanticError.comment="I represent an abstract semantic error thrown by the SemanticAnalyzer.\x0aSemantic errors can be unknown variable errors, etc.\x0aSee my subclasses for concrete errors.\x0a\x0aThe IDE should catch instances of Semantic error to deal with them when compiling";
+//>>excludeEnd("ide");
 
 
 smalltalk.addClass('InliningError', globals.SemanticError, [], 'Compiler-Exceptions');
+//>>excludeStart("ide", pragmas.excludeIdeData);
 globals.InliningError.comment="Instances of InliningError are signaled when using an `InliningCodeGenerator`in a `Compiler`.";
+//>>excludeEnd("ide");
 
 
 smalltalk.addClass('InvalidAssignmentError', globals.SemanticError, ['variableName'], 'Compiler-Exceptions');
+//>>excludeStart("ide", pragmas.excludeIdeData);
 globals.InvalidAssignmentError.comment="I get signaled when a pseudo variable gets assigned.";
+//>>excludeEnd("ide");
 smalltalk.addMethod(
 smalltalk.method({
 selector: "messageText",
 protocol: 'accessing',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
 $1=" Invalid assignment to variable: ".__comma(self._variableName());
 return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx1) {$ctx1.fill(self,"messageText",{},globals.InvalidAssignmentError)});
+//>>excludeEnd("ctx");
 },
+messageSends: [",", "variableName"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "messageText\x0a\x09^ ' Invalid assignment to variable: ', self variableName",
-messageSends: [",", "variableName"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.InvalidAssignmentError);
 
@@ -51,10 +67,12 @@ $1=self["@variableName"];
 return $1;
 
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "variableName\x0a\x09^ variableName",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.InvalidAssignmentError);
 
@@ -65,36 +83,49 @@ protocol: 'accessing',
 fn: function (aString){
 var self=this;
 self["@variableName"]=aString;
-return self
+return self;
+
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aString"],
 source: "variableName: aString\x0a\x09variableName := aString",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.InvalidAssignmentError);
 
 
 
 smalltalk.addClass('ShadowingVariableError', globals.SemanticError, ['variableName'], 'Compiler-Exceptions');
+//>>excludeStart("ide", pragmas.excludeIdeData);
 globals.ShadowingVariableError.comment="I get signaled when a variable in a block or method scope shadows a variable of the same name in an outer scope.";
+//>>excludeEnd("ide");
 smalltalk.addMethod(
 smalltalk.method({
 selector: "messageText",
 protocol: 'accessing',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
 $1=_st("Variable shadowing error: ".__comma(self._variableName())).__comma(" is already defined");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx[","]=1;
+//>>excludeEnd("ctx");
 return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx1) {$ctx1.fill(self,"messageText",{},globals.ShadowingVariableError)});
+//>>excludeEnd("ctx");
 },
+messageSends: [",", "variableName"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "messageText\x0a\x09^ 'Variable shadowing error: ', self variableName, ' is already defined'",
-messageSends: [",", "variableName"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.ShadowingVariableError);
 
@@ -109,10 +140,12 @@ $1=self["@variableName"];
 return $1;
 
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "variableName\x0a\x09^ variableName",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.ShadowingVariableError);
 
@@ -123,36 +156,49 @@ protocol: 'accessing',
 fn: function (aString){
 var self=this;
 self["@variableName"]=aString;
-return self
+return self;
+
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aString"],
 source: "variableName: aString\x0a\x09variableName := aString",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.ShadowingVariableError);
 
 
 
 smalltalk.addClass('UnknownVariableError', globals.SemanticError, ['variableName'], 'Compiler-Exceptions');
+//>>excludeStart("ide", pragmas.excludeIdeData);
 globals.UnknownVariableError.comment="I get signaled when a variable is not defined.\x0aThe default behavior is to allow it, as this is how Amber currently is able to seamlessly send messages to JavaScript objects.";
+//>>excludeEnd("ide");
 smalltalk.addMethod(
 smalltalk.method({
 selector: "messageText",
 protocol: 'accessing',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
 $1=_st("Unknown Variable error: ".__comma(self._variableName())).__comma(" is not defined");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx[","]=1;
+//>>excludeEnd("ctx");
 return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx1) {$ctx1.fill(self,"messageText",{},globals.UnknownVariableError)});
+//>>excludeEnd("ctx");
 },
+messageSends: [",", "variableName"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "messageText\x0a\x09^ 'Unknown Variable error: ', self variableName, ' is not defined'",
-messageSends: [",", "variableName"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.UnknownVariableError);
 
@@ -167,10 +213,12 @@ $1=self["@variableName"];
 return $1;
 
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "variableName\x0a\x09^ variableName",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.UnknownVariableError);
 
@@ -181,33 +229,45 @@ protocol: 'accessing',
 fn: function (aString){
 var self=this;
 self["@variableName"]=aString;
-return self
+return self;
+
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aString"],
 source: "variableName: aString\x0a\x09variableName := aString",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.UnknownVariableError);
 
 
 
 smalltalk.addClass('RethrowErrorHandler', globals.Object, [], 'Compiler-Exceptions');
+//>>excludeStart("ide", pragmas.excludeIdeData);
 globals.RethrowErrorHandler.comment="This class is used in the commandline version of the compiler.\x0aIt uses the handleError: message of ErrorHandler for printing the stacktrace and throws the error again as JS exception.\x0aAs a result Smalltalk errors are not swallowd by the Amber runtime and compilation can be aborted.";
+//>>excludeEnd("ide");
 smalltalk.addMethod(
 smalltalk.method({
 selector: "basicSignal:",
 protocol: 'error handling',
 fn: function (anError){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 throw anError;
-return self}, function($ctx1) {$ctx1.fill(self,"basicSignal:",{anError:anError},globals.RethrowErrorHandler)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"basicSignal:",{anError:anError},globals.RethrowErrorHandler)});
+//>>excludeEnd("ctx");
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["anError"],
 source: "basicSignal: anError\x0a        <throw anError>",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.RethrowErrorHandler);
 
@@ -217,14 +277,21 @@ selector: "handleError:",
 protocol: 'error handling',
 fn: function (anError){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self._basicSignal_(anError);
-return self}, function($ctx1) {$ctx1.fill(self,"handleError:",{anError:anError},globals.RethrowErrorHandler)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"handleError:",{anError:anError},globals.RethrowErrorHandler)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["basicSignal:"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["anError"],
 source: "handleError: anError\x0a        self basicSignal: anError",
-messageSends: ["basicSignal:"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.RethrowErrorHandler);
 

src/Examples.js

@@ -4,26 +4,39 @@ smalltalk.addPackage('Examples');
 smalltalk.packages["Examples"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
 smalltalk.addClass('Counter', globals.Widget, ['count', 'header'], 'Examples');
+//>>excludeStart("ide", pragmas.excludeIdeData);
 globals.Counter.comment="This is a trivial Widget example mimicking the classic Counter example in Seaside.\x0aIn order to play with it, just evaluate the doit below in a workspace.\x0aThen take a look in the HTML document above the IDE.\x0a\x0a\x09\x09Counter tryExample";
+//>>excludeEnd("ide");
 smalltalk.addMethod(
 smalltalk.method({
 selector: "decrease",
 protocol: 'actions',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self["@count"]=_st(self["@count"]).__minus((1));
 _st(self["@header"])._contents_((function(html){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 return _st(html)._with_(_st(self["@count"])._asString());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({html:html},$ctx1,1)});
+//>>excludeEnd("ctx");
 }));
-return self}, function($ctx1) {$ctx1.fill(self,"decrease",{},globals.Counter)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"decrease",{},globals.Counter)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["-", "contents:", "with:", "asString"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "decrease\x0a\x09count := count - 1.\x0a\x09header contents: [ :html | html with: count asString ]",
-messageSends: ["-", "contents:", "with:", "asString"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Counter);
 
@@ -33,19 +46,30 @@ selector: "increase",
 protocol: 'actions',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self["@count"]=_st(self["@count"]).__plus((1));
 _st(self["@header"])._contents_((function(html){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 return _st(html)._with_(_st(self["@count"])._asString());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({html:html},$ctx1,1)});
+//>>excludeEnd("ctx");
 }));
-return self}, function($ctx1) {$ctx1.fill(self,"increase",{},globals.Counter)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"increase",{},globals.Counter)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["+", "contents:", "with:", "asString"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "increase\x0a\x09count := count + 1.\x0a\x09header contents: [ :html | html with: count asString ]",
-messageSends: ["+", "contents:", "with:", "asString"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Counter);
 
@@ -55,16 +79,29 @@ selector: "initialize",
 protocol: 'initialization',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
-($ctx1.supercall = true, globals.Counter.superclass.fn.prototype._initialize.apply(_st(self), []));
+//>>excludeEnd("ctx");
+(
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+$ctx1.supercall = true, 
+//>>excludeEnd("ctx");
+globals.Counter.superclass.fn.prototype._initialize.apply(_st(self), []));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.supercall = false;
+//>>excludeEnd("ctx");;
 self["@count"]=(0);
-return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.Counter)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.Counter)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["initialize"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "initialize\x0a\x09super initialize.\x0a\x09count := 0",
-messageSends: ["initialize"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Counter);
 
@@ -74,36 +111,59 @@ selector: "renderOn:",
 protocol: 'rendering',
 fn: function (html){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$2,$3,$4,$5,$6;
 $1=_st(html)._h1();
 _st($1)._with_(_st(self["@count"])._asString());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["with:"]=1;
+//>>excludeEnd("ctx");
 $2=_st($1)._yourself();
 self["@header"]=$2;
 $3=_st(html)._button();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["button"]=1;
+//>>excludeEnd("ctx");
 _st($3)._with_("++");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["with:"]=2;
+//>>excludeEnd("ctx");
 $4=_st($3)._onClick_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 return self._increase();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
 }));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["onClick:"]=1;
+//>>excludeEnd("ctx");
 $5=_st(html)._button();
 _st($5)._with_("--");
 $6=_st($5)._onClick_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 return self._decrease();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)});
+//>>excludeEnd("ctx");
 }));
-return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},globals.Counter)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},globals.Counter)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["with:", "h1", "asString", "yourself", "button", "onClick:", "increase", "decrease"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["html"],
 source: "renderOn: html\x0a\x09header := html h1\x0a\x09\x09with: count asString;\x0a\x09\x09yourself.\x0a\x09html button\x0a\x09\x09with: '++';\x0a\x09\x09onClick: [ self increase ].\x0a\x09html button\x0a\x09\x09with: '--';\x0a\x09\x09onClick: [ self decrease ]",
-messageSends: ["with:", "h1", "asString", "yourself", "button", "onClick:", "increase", "decrease"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Counter);
 
@@ -114,14 +174,21 @@ selector: "tryExample",
 protocol: 'example',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 _st(self._new())._appendToJQuery_("body"._asJQuery());
-return self}, function($ctx1) {$ctx1.fill(self,"tryExample",{},globals.Counter.klass)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"tryExample",{},globals.Counter.klass)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["appendToJQuery:", "new", "asJQuery"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "tryExample\x0a\x09\x22In order to play with the Counter, just select the\x0a\x09doit below and press the Do it button. Then take a\x0a\x09look in the HTML document above the IDE.\x22\x0a\x0a\x09\x22Counter tryExample\x22\x0a\x09\x09self new appendToJQuery: 'body' asJQuery",
-messageSends: ["appendToJQuery:", "new", "asJQuery"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Counter.klass);
 

src/Kernel-Exceptions.js

@@ -4,21 +4,30 @@ smalltalk.addPackage('Kernel-Exceptions');
 smalltalk.packages["Kernel-Exceptions"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
 smalltalk.addClass('Error', globals.Object, ['messageText'], 'Kernel-Exceptions');
+//>>excludeStart("ide", pragmas.excludeIdeData);
 globals.Error.comment="From the ANSI standard:\x0a\x0aThis protocol describes the behavior of instances of class `Error`.\x0aThese are used to represent error conditions that prevent the normal continuation of processing.\x0aActual error exceptions used by an application may be subclasses of this class.\x0aAs `Error` is explicitly specified to be subclassable, conforming implementations must implement its behavior in a non-fragile manner.";
+//>>excludeEnd("ide");
 smalltalk.addMethod(
 smalltalk.method({
 selector: "beHandled",
 protocol: 'accessing',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self.amberHandled = true;
-return self}, function($ctx1) {$ctx1.fill(self,"beHandled",{},globals.Error)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"beHandled",{},globals.Error)});
+//>>excludeEnd("ctx");
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "beHandled\x0a\x09<self.amberHandled = true>",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Error);
 
@@ -28,14 +37,21 @@ selector: "beUnhandled",
 protocol: 'accessing',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self.amberHandled = false;
-return self}, function($ctx1) {$ctx1.fill(self,"beUnhandled",{},globals.Error)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"beUnhandled",{},globals.Error)});
+//>>excludeEnd("ctx");
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "beUnhandled\x0a\x09<self.amberHandled = false>",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Error);
 
@@ -45,14 +61,21 @@ selector: "context",
 protocol: 'accessing',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 return self.context;
-return self}, function($ctx1) {$ctx1.fill(self,"context",{},globals.Error)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"context",{},globals.Error)});
+//>>excludeEnd("ctx");
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "context\x0a\x09<return self.context>",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Error);
 
@@ -62,14 +85,21 @@ selector: "initialize",
 protocol: 'initialization',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self._messageText_("Errorclass: ".__comma(_st(self._class())._name()));
-return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.Error)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.Error)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["messageText:", ",", "name", "class"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "initialize\x0a\x09self messageText: 'Errorclass: ', (self class name).",
-messageSends: ["messageText:", ",", "name", "class"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Error);
 
@@ -79,14 +109,21 @@ selector: "isSmalltalkError",
 protocol: 'testing',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 return self.smalltalkError === true;
-return self}, function($ctx1) {$ctx1.fill(self,"isSmalltalkError",{},globals.Error)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"isSmalltalkError",{},globals.Error)});
+//>>excludeEnd("ctx");
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isSmalltalkError\x0a\x09<return self.smalltalkError === true>",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Error);
 
@@ -96,14 +133,21 @@ selector: "jsStack",
 protocol: 'accessing',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 return self.stack;
-return self}, function($ctx1) {$ctx1.fill(self,"jsStack",{},globals.Error)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"jsStack",{},globals.Error)});
+//>>excludeEnd("ctx");
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "jsStack\x0a\x09<return self.stack>",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Error);
 
@@ -118,10 +162,12 @@ $1=self["@messageText"];
 return $1;
 
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "messageText\x0a\x09^ messageText",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Error);
 
@@ -132,12 +178,15 @@ protocol: 'accessing',
 fn: function (aString){
 var self=this;
 self["@messageText"]=aString;
-return self
+return self;
+
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aString"],
 source: "messageText: aString\x0a\x09messageText := aString",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Error);
 
@@ -147,17 +196,24 @@ selector: "resignal",
 protocol: 'signaling',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 
 		self.amberHandled = false;
 		throw(self);
 	;
-return self}, function($ctx1) {$ctx1.fill(self,"resignal",{},globals.Error)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"resignal",{},globals.Error)});
+//>>excludeEnd("ctx");
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "resignal\x0a\x09\x22Resignal the receiver without changing its exception context\x22\x0a\x09\x0a\x09<\x0a\x09\x09self.amberHandled = false;\x0a\x09\x09throw(self);\x0a\x09>",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Error);
 
@@ -167,18 +223,25 @@ selector: "signal",
 protocol: 'signaling',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 
 		self.amberHandled = false;
 		self.context = smalltalk.getThisContext(); 
 		self.smalltalkError = true; throw(self)
 	;
-return self}, function($ctx1) {$ctx1.fill(self,"signal",{},globals.Error)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"signal",{},globals.Error)});
+//>>excludeEnd("ctx");
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "signal\x0a\x09<\x0a\x09\x09self.amberHandled = false;\x0a\x09\x09self.context = smalltalk.getThisContext(); \x0a\x09\x09self.smalltalkError = true; throw(self)\x0a\x09>",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Error);
 
@@ -188,15 +251,22 @@ selector: "signal:",
 protocol: 'signaling',
 fn: function (aString){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self._messageText_(aString);
 self._signal();
-return self}, function($ctx1) {$ctx1.fill(self,"signal:",{aString:aString},globals.Error)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"signal:",{aString:aString},globals.Error)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["messageText:", "signal"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aString"],
 source: "signal: aString\x0a\x09self messageText: aString.\x0a\x09self signal",
-messageSends: ["messageText:", "signal"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Error);
 
@@ -206,16 +276,22 @@ selector: "signalerContext",
 protocol: 'accessing',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
 $1=self._signalerContextFrom_(self._context());
 return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx1) {$ctx1.fill(self,"signalerContext",{},globals.Error)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["signalerContextFrom:", "context"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "signalerContext\x0a\x09^ self signalerContextFrom: self context",
-messageSends: ["signalerContextFrom:", "context"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Error);
 
@@ -225,29 +301,47 @@ selector: "signalerContextFrom:",
 protocol: 'accessing',
 fn: function (aContext){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $4,$3,$2,$1;
 $1=_st(aContext)._findContextSuchThat_((function(context){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 $4=_st(context)._receiver();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["receiver"]=1;
+//>>excludeEnd("ctx");
 $3=_st($4).__eq_eq(self);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["=="]=1;
+//>>excludeEnd("ctx");
 $2=_st($3)._or_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx3) {
+//>>excludeEnd("ctx");
 return _st(_st(context)._receiver()).__eq_eq(self._class());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)});
+//>>excludeEnd("ctx");
 }));
 return _st($2)._not();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({context:context},$ctx1,1)});
+//>>excludeEnd("ctx");
 }));
 return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx1) {$ctx1.fill(self,"signalerContextFrom:",{aContext:aContext},globals.Error)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["findContextSuchThat:", "not", "or:", "==", "receiver", "class"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aContext"],
 source: "signalerContextFrom: aContext\x0a\x09\x22Find the first sender of signal(:), the first context which is neither \x0a\x09for an instance method nor for a class side method of Exception (or subclass).\x0a\x09This will make sure that the same context is found for both, `Error signal` \x0a\x09and `Error new signal`\x22\x0a\x0a\x09^ aContext findContextSuchThat: [ :context |\x0a\x09\x09(context receiver == self \x0a\x09\x09or: [ context receiver == self class ]) not ]",
-messageSends: ["findContextSuchThat:", "not", "or:", "==", "receiver", "class"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Error);
 
@@ -257,14 +351,21 @@ selector: "wasHandled",
 protocol: 'testing',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 return self.amberHandled || false;
-return self}, function($ctx1) {$ctx1.fill(self,"wasHandled",{},globals.Error)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"wasHandled",{},globals.Error)});
+//>>excludeEnd("ctx");
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "wasHandled\x0a\x09<return self.amberHandled || false>",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Error);
 
@@ -278,10 +379,12 @@ var self=this;
 return "exception";
 
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "heliosClass\x0a\x09^ 'exception'",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Error.klass);
 
@@ -291,16 +394,22 @@ selector: "signal",
 protocol: 'instance creation',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
 $1=_st(self._new())._signal();
 return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx1) {$ctx1.fill(self,"signal",{},globals.Error.klass)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["signal", "new"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "signal\x0a\x09^ self new signal",
-messageSends: ["signal", "new"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Error.klass);
 
@@ -310,22 +419,30 @@ selector: "signal:",
 protocol: 'instance creation',
 fn: function (aString){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
 $1=_st(self._new())._signal_(aString);
 return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx1) {$ctx1.fill(self,"signal:",{aString:aString},globals.Error.klass)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["signal:", "new"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aString"],
 source: "signal: aString\x0a\x09^ self new\x0a\x09\x09signal: aString",
-messageSends: ["signal:", "new"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Error.klass);
 
 
 smalltalk.addClass('Halt', globals.Error, [], 'Kernel-Exceptions');
+//>>excludeStart("ide", pragmas.excludeIdeData);
 globals.Halt.comment="I am provided to support `Object>>#halt`.";
+//>>excludeEnd("ide");
 smalltalk.addMethod(
 smalltalk.method({
 selector: "messageText",
@@ -335,10 +452,12 @@ var self=this;
 return "Halt encountered";
 
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "messageText\x0a\x09^ 'Halt encountered'",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Halt);
 
@@ -348,55 +467,88 @@ selector: "signalerContextFrom:",
 protocol: 'accessing',
 fn: function (aContext){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $4,$3,$2,$1;
 $1=_st(aContext)._findContextSuchThat_((function(context){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 $4=_st(context)._receiver();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["receiver"]=1;
+//>>excludeEnd("ctx");
 $3=_st($4).__eq_eq(self);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["=="]=1;
+//>>excludeEnd("ctx");
 $2=_st($3)._or_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx3) {
+//>>excludeEnd("ctx");
 return _st(_st(_st(context)._receiver()).__eq_eq(self._class()))._or_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx4) {
+//>>excludeEnd("ctx");
 return _st(_st(_st(context)._method())._selector()).__eq("halt");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx4) {$ctx4.fillBlock({},$ctx3,3)});
+//>>excludeEnd("ctx");
 }));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)});
+//>>excludeEnd("ctx");
 }));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["or:"]=1;
+//>>excludeEnd("ctx");
 return _st($2)._not();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({context:context},$ctx1,1)});
+//>>excludeEnd("ctx");
 }));
 return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx1) {$ctx1.fill(self,"signalerContextFrom:",{aContext:aContext},globals.Halt)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["findContextSuchThat:", "not", "or:", "==", "receiver", "class", "=", "selector", "method"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aContext"],
 source: "signalerContextFrom: aContext\x0a\x09\x22specialized version to find the proper context to open the debugger on.\x0a\x09This will find the first context whose method is no longer on `Halt` or \x0a\x09`Halt class` nor is `#halt` method itself.\x22\x0a\x09\x0a\x09^ aContext findContextSuchThat: [ :context |\x0a\x09\x09(context receiver == self \x0a\x09\x09or: [ (context receiver == self class) \x0a\x09\x09or: [ context method selector = #halt ]]) not ]",
-messageSends: ["findContextSuchThat:", "not", "or:", "==", "receiver", "class", "=", "selector", "method"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.Halt);
 
 
 
 smalltalk.addClass('JavaScriptException', globals.Error, ['exception'], 'Kernel-Exceptions');
+//>>excludeStart("ide", pragmas.excludeIdeData);
 globals.JavaScriptException.comment="A JavaScriptException is thrown when a non-Smalltalk exception occurs while in the Smalltalk stack.\x0aSee `boot.js` `inContext()` and `BlockClosure >> on:do:`";
+//>>excludeEnd("ide");
 smalltalk.addMethod(
 smalltalk.method({
 selector: "context:",
 protocol: 'accessing',
 fn: function (aMethodContext){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self.context = aMethodContext;
-return self}, function($ctx1) {$ctx1.fill(self,"context:",{aMethodContext:aMethodContext},globals.JavaScriptException)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"context:",{aMethodContext:aMethodContext},globals.JavaScriptException)});
+//>>excludeEnd("ctx");
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aMethodContext"],
 source: "context: aMethodContext\x0a\x09\x22Set the context from the outside.\x0a\x09See boot.js `inContext()` exception handling\x22\x0a\x09\x0a\x09<self.context = aMethodContext>",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.JavaScriptException);
 
@@ -411,10 +563,12 @@ $1=self["@exception"];
 return $1;
 
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "exception\x0a\x09^ exception",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.JavaScriptException);
 
@@ -425,12 +579,15 @@ protocol: 'accessing',
 fn: function (anException){
 var self=this;
 self["@exception"]=anException;
-return self
+return self;
+
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["anException"],
 source: "exception: anException\x0a\x09exception := anException",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.JavaScriptException);
 
@@ -440,14 +597,21 @@ selector: "messageText",
 protocol: 'accessing',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 return 'JavaScript exception: ' + self["@exception"].toString();
-return self}, function($ctx1) {$ctx1.fill(self,"messageText",{},globals.JavaScriptException)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"messageText",{},globals.JavaScriptException)});
+//>>excludeEnd("ctx");
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "messageText\x0a\x09<return 'JavaScript exception: ' + self[\x22@exception\x22].toString()>",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.JavaScriptException);
 
@@ -458,19 +622,25 @@ selector: "on:",
 protocol: 'instance creation',
 fn: function (anException){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $2,$3,$1;
 $2=self._new();
 _st($2)._exception_(anException);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx1) {$ctx1.fill(self,"on:",{anException:anException},globals.JavaScriptException.klass)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["exception:", "new", "yourself"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["anException"],
 source: "on: anException\x0a\x09^ self new\x0a\x09\x09exception: anException;\x0a\x09\x09yourself",
-messageSends: ["exception:", "new", "yourself"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.JavaScriptException.klass);
 
@@ -480,7 +650,9 @@ selector: "on:context:",
 protocol: 'instance creation',
 fn: function (anException,aMethodContext){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $2,$3,$1;
 $2=self._new();
 _st($2)._exception_(anException);
@@ -488,18 +660,24 @@ _st($2)._context_(aMethodContext);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx1) {$ctx1.fill(self,"on:context:",{anException:anException,aMethodContext:aMethodContext},globals.JavaScriptException.klass)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["exception:", "new", "context:", "yourself"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["anException", "aMethodContext"],
 source: "on: anException context: aMethodContext\x0a\x09^ self new\x0a\x09\x09exception: anException;\x0a\x09\x09context: aMethodContext;\x0a\x09\x09yourself",
-messageSends: ["exception:", "new", "context:", "yourself"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.JavaScriptException.klass);
 
 
 smalltalk.addClass('MessageNotUnderstood', globals.Error, ['message', 'receiver'], 'Kernel-Exceptions');
+//>>excludeStart("ide", pragmas.excludeIdeData);
 globals.MessageNotUnderstood.comment="This exception is provided to support `Object>>doesNotUnderstand:`.";
+//>>excludeEnd("ide");
 smalltalk.addMethod(
 smalltalk.method({
 selector: "message",
@@ -511,10 +689,12 @@ $1=self["@message"];
 return $1;
 
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "message\x0a\x09^ message",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.MessageNotUnderstood);
 
@@ -525,12 +705,15 @@ protocol: 'accessing',
 fn: function (aMessage){
 var self=this;
 self["@message"]=aMessage;
-return self
+return self;
+
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aMessage"],
 source: "message: aMessage\x0a\x09message := aMessage",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.MessageNotUnderstood);
 
@@ -540,17 +723,25 @@ selector: "messageText",
 protocol: 'accessing',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
 $1=_st(_st(_st(self._receiver())._asString()).__comma(" does not understand #")).__comma(_st(self._message())._selector());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx[","]=1;
+//>>excludeEnd("ctx");
 return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx1) {$ctx1.fill(self,"messageText",{},globals.MessageNotUnderstood)});
+//>>excludeEnd("ctx");
 },
+messageSends: [",", "asString", "receiver", "selector", "message"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "messageText\x0a\x09^ self receiver asString, ' does not understand #', self message selector",
-messageSends: [",", "asString", "receiver", "selector", "message"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.MessageNotUnderstood);
 
@@ -565,10 +756,12 @@ $1=self["@receiver"];
 return $1;
 
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "receiver\x0a\x09^ receiver",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.MessageNotUnderstood);
 
@@ -579,19 +772,24 @@ protocol: 'accessing',
 fn: function (anObject){
 var self=this;
 self["@receiver"]=anObject;
-return self
+return self;
+
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["anObject"],
 source: "receiver: anObject\x0a\x09receiver := anObject",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.MessageNotUnderstood);
 
 
 
 smalltalk.addClass('NonBooleanReceiver', globals.Error, ['object'], 'Kernel-Exceptions');
+//>>excludeStart("ide", pragmas.excludeIdeData);
 globals.NonBooleanReceiver.comment="NonBooleanReceiver exceptions may be thrown when executing inlined methods such as `#ifTrue:` with a non boolean receiver.";
+//>>excludeEnd("ide");
 smalltalk.addMethod(
 smalltalk.method({
 selector: "object",
@@ -603,10 +801,12 @@ $1=self["@object"];
 return $1;
 
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "object\x0a\x09^ object",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.NonBooleanReceiver);
 
@@ -617,18 +817,23 @@ protocol: 'accessing',
 fn: function (anObject){
 var self=this;
 self["@object"]=anObject;
-return self
+return self;
+
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["anObject"],
 source: "object: anObject\x0a\x09object := anObject",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.NonBooleanReceiver);
 
 
 
 smalltalk.addClass('PackageCommitError', globals.Error, [], 'Kernel-Exceptions');
+//>>excludeStart("ide", pragmas.excludeIdeData);
 globals.PackageCommitError.comment="I get signaled when an attempt to commit a package has failed.";
+//>>excludeEnd("ide");
 
 });

src/Kernel-Transcript.js

@@ -4,19 +4,24 @@ smalltalk.addPackage('Kernel-Transcript');
 smalltalk.packages["Kernel-Transcript"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
 smalltalk.addClass('ConsoleTranscript', globals.Object, ['textarea'], 'Kernel-Transcript');
+//>>excludeStart("ide", pragmas.excludeIdeData);
 globals.ConsoleTranscript.comment="I am a specific transcript emitting to the JavaScript console.\x0a\x0aIf no other transcript is registered, I am the default.";
+//>>excludeEnd("ide");
 smalltalk.addMethod(
 smalltalk.method({
 selector: "clear",
 protocol: 'printing',
 fn: function (){
 var self=this;
-return self
+return self;
+
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "clear\x0a\x09\x22no op\x22",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.ConsoleTranscript);
 
@@ -26,12 +31,15 @@ selector: "cr",
 protocol: 'printing',
 fn: function (){
 var self=this;
-return self
+return self;
+
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "cr\x0a\x09\x22no op\x22",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.ConsoleTranscript);
 
@@ -41,12 +49,15 @@ selector: "open",
 protocol: 'actions',
 fn: function (){
 var self=this;
-return self
+return self;
+
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "open",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.ConsoleTranscript);
 
@@ -56,14 +67,21 @@ selector: "show:",
 protocol: 'printing',
 fn: function (anObject){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 console.log(String(_st(anObject)._asString()));
-return self}, function($ctx1) {$ctx1.fill(self,"show:",{anObject:anObject},globals.ConsoleTranscript)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"show:",{anObject:anObject},globals.ConsoleTranscript)});
+//>>excludeEnd("ctx");
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["anObject"],
 source: "show: anObject\x0a\x22Smalltalk objects should have no trouble displaying themselves on the Transcript; Javascript objects don't know how, so must be wrapped in a JSObectProxy.\x22\x0a<console.log(String(_st(anObject)._asString()))>",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.ConsoleTranscript);
 
@@ -75,14 +93,21 @@ protocol: 'initialization',
 fn: function (){
 var self=this;
 function $Transcript(){return globals.Transcript||(typeof Transcript=="undefined"?nil:Transcript)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 _st($Transcript())._registerIfNone_(self._new());
-return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.ConsoleTranscript.klass)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.ConsoleTranscript.klass)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["registerIfNone:", "new"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "initialize\x0a\x09Transcript registerIfNone: self new",
-messageSends: ["registerIfNone:", "new"],
 referencedClasses: ["Transcript"]
+//>>excludeEnd("ide");
 }),
 globals.ConsoleTranscript.klass);
 

src/SUnit-Tests.js

@@ -4,7 +4,9 @@ smalltalk.addPackage('SUnit-Tests');
 smalltalk.packages["SUnit-Tests"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
 smalltalk.addClass('ExampleSetTest', globals.TestCase, ['empty', 'full'], 'SUnit-Tests');
+//>>excludeStart("ide", pragmas.excludeIdeData);
 globals.ExampleSetTest.comment="ExampleSetTest is taken from Pharo 1.4.\x0a\x0aTHe purpose of this class is to demonstrate a simple use case of the test framework.";
+//>>excludeEnd("ide");
 smalltalk.addMethod(
 smalltalk.method({
 selector: "setUp",
@@ -12,15 +14,22 @@ protocol: 'running',
 fn: function (){
 var self=this;
 function $Set(){return globals.Set||(typeof Set=="undefined"?nil:Set)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self["@empty"]=_st($Set())._new();
 self["@full"]=_st($Set())._with_with_((5),"abc");
-return self}, function($ctx1) {$ctx1.fill(self,"setUp",{},globals.ExampleSetTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"setUp",{},globals.ExampleSetTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["new", "with:with:"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "setUp\x0a\x09empty := Set new.\x0a\x09full := Set with: 5 with: #abc",
-messageSends: ["new", "with:with:"],
 referencedClasses: ["Set"]
+//>>excludeEnd("ide");
 }),
 globals.ExampleSetTest);
 
@@ -30,15 +39,22 @@ selector: "testAdd",
 protocol: 'tests',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 _st(self["@empty"])._add_((5));
 self._assert_(_st(self["@empty"])._includes_((5)));
-return self}, function($ctx1) {$ctx1.fill(self,"testAdd",{},globals.ExampleSetTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testAdd",{},globals.ExampleSetTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["add:", "assert:", "includes:"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testAdd\x0a\x09empty add: 5.\x0a\x09self assert: (empty includes: 5)",
-messageSends: ["add:", "assert:", "includes:"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.ExampleSetTest);
 
@@ -48,15 +64,22 @@ selector: "testGrow",
 protocol: 'tests',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 _st(self["@empty"])._addAll_((1)._to_((100)));
 self._assert_equals_(_st(self["@empty"])._size(),(100));
-return self}, function($ctx1) {$ctx1.fill(self,"testGrow",{},globals.ExampleSetTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testGrow",{},globals.ExampleSetTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["addAll:", "to:", "assert:equals:", "size"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testGrow\x0a\x09empty addAll: (1 to: 100).\x0a\x09self assert: empty size equals: 100",
-messageSends: ["addAll:", "to:", "assert:equals:", "size"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.ExampleSetTest);
 
@@ -67,24 +90,41 @@ protocol: 'tests',
 fn: function (){
 var self=this;
 function $Error(){return globals.Error||(typeof Error=="undefined"?nil:Error)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self._should_raise_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 return _st(self["@empty"])._at_((5));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
 }),$Error());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["should:raise:"]=1;
+//>>excludeEnd("ctx");
 self._should_raise_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 return _st(self["@empty"])._at_put_((5),"abc");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)});
+//>>excludeEnd("ctx");
 }),$Error());
-return self}, function($ctx1) {$ctx1.fill(self,"testIllegal",{},globals.ExampleSetTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testIllegal",{},globals.ExampleSetTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["should:raise:", "at:", "at:put:"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testIllegal\x0a\x09self\x0a\x09\x09should: [ empty at: 5 ]\x0a\x09\x09raise: Error.\x0a\x09self\x0a\x09\x09should: [ empty at: 5 put: #abc ]\x0a\x09\x09raise: Error",
-messageSends: ["should:raise:", "at:", "at:put:"],
 referencedClasses: ["Error"]
+//>>excludeEnd("ide");
 }),
 globals.ExampleSetTest);
 
@@ -94,19 +134,30 @@ selector: "testIncludes",
 protocol: 'tests',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
 $1=_st(self["@full"])._includes_((5));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["includes:"]=1;
+//>>excludeEnd("ctx");
 self._assert_($1);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["assert:"]=1;
+//>>excludeEnd("ctx");
 self._assert_(_st(self["@full"])._includes_("abc"));
-return self}, function($ctx1) {$ctx1.fill(self,"testIncludes",{},globals.ExampleSetTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testIncludes",{},globals.ExampleSetTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["assert:", "includes:"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testIncludes\x0a\x09self assert: (full includes: 5).\x0a\x09self assert: (full includes: #abc)",
-messageSends: ["assert:", "includes:"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.ExampleSetTest);
 
@@ -116,24 +167,39 @@ selector: "testOccurrences",
 protocol: 'tests',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$2;
 $1=_st(self["@empty"])._occurrencesOf_((0));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["occurrencesOf:"]=1;
+//>>excludeEnd("ctx");
 self._assert_equals_($1,(0));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["assert:equals:"]=1;
+//>>excludeEnd("ctx");
 $2=_st(self["@full"])._occurrencesOf_((5));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["occurrencesOf:"]=2;
+//>>excludeEnd("ctx");
 self._assert_equals_($2,(1));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["assert:equals:"]=2;
+//>>excludeEnd("ctx");
 _st(self["@full"])._add_((5));
 self._assert_equals_(_st(self["@full"])._occurrencesOf_((5)),(1));
-return self}, function($ctx1) {$ctx1.fill(self,"testOccurrences",{},globals.ExampleSetTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testOccurrences",{},globals.ExampleSetTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["assert:equals:", "occurrencesOf:", "add:"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testOccurrences\x0a\x09self assert: (empty occurrencesOf: 0) equals: 0.\x0a\x09self assert: (full occurrencesOf: 5) equals: 1.\x0a\x09full add: 5.\x0a\x09self assert: (full occurrencesOf: 5) equals: 1",
-messageSends: ["assert:equals:", "occurrencesOf:", "add:"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.ExampleSetTest);
 
@@ -143,19 +209,28 @@ selector: "testRemove",
 protocol: 'tests',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
 _st(self["@full"])._remove_((5));
 $1=_st(self["@full"])._includes_("abc");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["includes:"]=1;
+//>>excludeEnd("ctx");
 self._assert_($1);
 self._deny_(_st(self["@full"])._includes_((5)));
-return self}, function($ctx1) {$ctx1.fill(self,"testRemove",{},globals.ExampleSetTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testRemove",{},globals.ExampleSetTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["remove:", "assert:", "includes:", "deny:"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testRemove\x0a\x09full remove: 5.\x0a\x09self assert: (full includes: #abc).\x0a\x09self deny: (full includes: 5)",
-messageSends: ["remove:", "assert:", "includes:", "deny:"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.ExampleSetTest);
 
@@ -168,22 +243,33 @@ selector: "fakeError",
 protocol: 'helpers',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self["@flag"]="bad";
 self._timeout_((30));
 self["@flag"]=_st(self._async_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 self["@flag"]="ok";
 self["@flag"];
 return self._error_("Intentional");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
 })))._valueWithTimeout_((20));
-return self}, function($ctx1) {$ctx1.fill(self,"fakeError",{},globals.SUnitAsyncTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"fakeError",{},globals.SUnitAsyncTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["timeout:", "valueWithTimeout:", "async:", "error:"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "fakeError\x0a\x09flag := 'bad'.\x0a\x09self timeout: 30.\x0a\x09flag := (self async: [ flag := 'ok'. self error: 'Intentional' ]) valueWithTimeout: 20",
-messageSends: ["timeout:", "valueWithTimeout:", "async:", "error:"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.SUnitAsyncTest);
 
@@ -193,20 +279,31 @@ selector: "fakeErrorFailingInTearDown",
 protocol: 'helpers',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self["@flag"]="bad";
 self._timeout_((30));
 self["@flag"]=_st(self._async_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 return self._error_("Intentional");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
 })))._valueWithTimeout_((20));
-return self}, function($ctx1) {$ctx1.fill(self,"fakeErrorFailingInTearDown",{},globals.SUnitAsyncTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"fakeErrorFailingInTearDown",{},globals.SUnitAsyncTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["timeout:", "valueWithTimeout:", "async:", "error:"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "fakeErrorFailingInTearDown\x0a\x09flag := 'bad'.\x0a\x09self timeout: 30.\x0a\x09flag := (self async: [ self error: 'Intentional' ]) valueWithTimeout: 20",
-messageSends: ["timeout:", "valueWithTimeout:", "async:", "error:"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.SUnitAsyncTest);
 
@@ -216,22 +313,33 @@ selector: "fakeFailure",
 protocol: 'helpers',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self["@flag"]="bad";
 self._timeout_((30));
 self["@flag"]=_st(self._async_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 self["@flag"]="ok";
 self["@flag"];
 return self._assert_(false);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
 })))._valueWithTimeout_((20));
-return self}, function($ctx1) {$ctx1.fill(self,"fakeFailure",{},globals.SUnitAsyncTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"fakeFailure",{},globals.SUnitAsyncTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["timeout:", "valueWithTimeout:", "async:", "assert:"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "fakeFailure\x0a\x09flag := 'bad'.\x0a\x09self timeout: 30.\x0a\x09flag := (self async: [ flag := 'ok'. self assert: false ]) valueWithTimeout: 20",
-messageSends: ["timeout:", "valueWithTimeout:", "async:", "assert:"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.SUnitAsyncTest);
 
@@ -241,29 +349,50 @@ selector: "fakeMultipleTimeoutFailing",
 protocol: 'helpers',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
 self._timeout_((100));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["timeout:"]=1;
+//>>excludeEnd("ctx");
 $1=self._async_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 self._timeout_((20));
 return _st(self._async_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx3) {
+//>>excludeEnd("ctx");
 return self._finished();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)});
+//>>excludeEnd("ctx");
 })))._valueWithTimeout_((30));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
 }));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["async:"]=1;
+//>>excludeEnd("ctx");
 _st($1)._valueWithTimeout_((20));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["valueWithTimeout:"]=1;
-return self}, function($ctx1) {$ctx1.fill(self,"fakeMultipleTimeoutFailing",{},globals.SUnitAsyncTest)});
+//>>excludeEnd("ctx");
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"fakeMultipleTimeoutFailing",{},globals.SUnitAsyncTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["timeout:", "valueWithTimeout:", "async:", "finished"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "fakeMultipleTimeoutFailing\x0a\x09self timeout: 100.\x0a\x09(self async: [ \x0a\x09\x09self timeout: 20.\x0a\x09\x09(self async: [ self finished ]) valueWithTimeout: 30\x0a\x09]) valueWithTimeout: 20",
-messageSends: ["timeout:", "valueWithTimeout:", "async:", "finished"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.SUnitAsyncTest);
 
@@ -273,29 +402,50 @@ selector: "fakeMultipleTimeoutPassing",
 protocol: 'helpers',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
 self._timeout_((20));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["timeout:"]=1;
+//>>excludeEnd("ctx");
 $1=self._async_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 self._timeout_((40));
 return _st(self._async_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx3) {
+//>>excludeEnd("ctx");
 return self._finished();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)});
+//>>excludeEnd("ctx");
 })))._valueWithTimeout_((20));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
 }));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["async:"]=1;
+//>>excludeEnd("ctx");
 _st($1)._valueWithTimeout_((10));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["valueWithTimeout:"]=1;
-return self}, function($ctx1) {$ctx1.fill(self,"fakeMultipleTimeoutPassing",{},globals.SUnitAsyncTest)});
+//>>excludeEnd("ctx");
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"fakeMultipleTimeoutPassing",{},globals.SUnitAsyncTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["timeout:", "valueWithTimeout:", "async:", "finished"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "fakeMultipleTimeoutPassing\x0a\x09self timeout: 20.\x0a\x09(self async: [\x0a\x09\x09self timeout: 40.\x0a\x09\x09(self async: [ self finished ]) valueWithTimeout: 20\x0a\x09]) valueWithTimeout: 10",
-messageSends: ["timeout:", "valueWithTimeout:", "async:", "finished"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.SUnitAsyncTest);
 
@@ -305,19 +455,30 @@ selector: "fakeTimeout",
 protocol: 'helpers',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self._timeout_((10));
 _st(self._async_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 return self._finished();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
 })))._valueWithTimeout_((20));
-return self}, function($ctx1) {$ctx1.fill(self,"fakeTimeout",{},globals.SUnitAsyncTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"fakeTimeout",{},globals.SUnitAsyncTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["timeout:", "valueWithTimeout:", "async:", "finished"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "fakeTimeout\x0a\x09self timeout: 10.\x0a\x09(self async: [ self finished ]) valueWithTimeout: 20",
-messageSends: ["timeout:", "valueWithTimeout:", "async:", "finished"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.SUnitAsyncTest);
 
@@ -327,20 +488,30 @@ selector: "selectorSetOf:",
 protocol: 'private',
 fn: function (aCollection){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
 $1=_st(_st(aCollection)._collect_((function(each){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 return _st(each)._selector();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)});
+//>>excludeEnd("ctx");
 })))._asSet();
 return $1;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx1) {$ctx1.fill(self,"selectorSetOf:",{aCollection:aCollection},globals.SUnitAsyncTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["asSet", "collect:", "selector"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aCollection"],
 source: "selectorSetOf: aCollection\x0a\x09^ (aCollection collect: [ :each | each selector ]) asSet",
-messageSends: ["asSet", "collect:", "selector"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.SUnitAsyncTest);
 
@@ -351,12 +522,15 @@ protocol: 'running',
 fn: function (){
 var self=this;
 self["@flag"]="ok";
-return self
+return self;
+
 },
+messageSends: [],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "setUp\x0a\x09flag := 'ok'",
-messageSends: [],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.SUnitAsyncTest);
 
@@ -366,14 +540,21 @@ selector: "tearDown",
 protocol: 'running',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self._assert_equals_("ok",self["@flag"]);
-return self}, function($ctx1) {$ctx1.fill(self,"tearDown",{},globals.SUnitAsyncTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"tearDown",{},globals.SUnitAsyncTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["assert:equals:"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "tearDown\x0a\x09self assert: 'ok' equals: flag",
-messageSends: ["assert:equals:"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.SUnitAsyncTest);
 
@@ -386,45 +567,72 @@ var self=this;
 var suite,runner,result,assertBlock;
 function $TestSuiteRunner(){return globals.TestSuiteRunner||(typeof TestSuiteRunner=="undefined"?nil:TestSuiteRunner)}
 function $ResultAnnouncement(){return globals.ResultAnnouncement||(typeof ResultAnnouncement=="undefined"?nil:ResultAnnouncement)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$2,$3,$4;
 suite=["fakeError", "fakeErrorFailingInTearDown", "fakeFailure", "testPass"]._collect_((function(each){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 return _st(self._class())._selector_(each);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)});
+//>>excludeEnd("ctx");
 }));
 runner=_st($TestSuiteRunner())._on_(suite);
 self._timeout_((200));
 result=_st(runner)._result();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["result"]=1;
+//>>excludeEnd("ctx");
 assertBlock=self._async_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 $1=self._selectorSetOf_(_st(result)._errors());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["selectorSetOf:"]=1;
+//>>excludeEnd("ctx");
 $2=["fakeError"]._asSet();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["asSet"]=1;
+//>>excludeEnd("ctx");
 self._assert_equals_($1,$2);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["assert:equals:"]=1;
+//>>excludeEnd("ctx");
 self._assert_equals_(self._selectorSetOf_(_st(result)._failures()),["fakeErrorFailingInTearDown", "fakeFailure"]._asSet());
 return self._finished();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)});
+//>>excludeEnd("ctx");
 }));
 _st(_st(runner)._announcer())._on_do_($ResultAnnouncement(),(function(ann){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 $3=_st(_st(ann)._result()).__eq_eq(result);
 if(smalltalk.assert($3)){
 $4=_st(_st(result)._runs()).__eq(_st(result)._total());
 return _st($4)._ifTrue_(assertBlock);
 };
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({ann:ann},$ctx1,3)});
+//>>excludeEnd("ctx");
 }));
 _st(runner)._run();
-return self}, function($ctx1) {$ctx1.fill(self,"testAsyncErrorsAndFailures",{suite:suite,runner:runner,result:result,assertBlock:assertBlock},globals.SUnitAsyncTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testAsyncErrorsAndFailures",{suite:suite,runner:runner,result:result,assertBlock:assertBlock},globals.SUnitAsyncTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["collect:", "selector:", "class", "on:", "timeout:", "result", "async:", "assert:equals:", "selectorSetOf:", "errors", "asSet", "failures", "finished", "on:do:", "announcer", "ifTrue:", "==", "=", "runs", "total", "run"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testAsyncErrorsAndFailures\x0a\x09| suite runner result assertBlock |\x0a\x09suite := #('fakeError' 'fakeErrorFailingInTearDown' 'fakeFailure' 'testPass') collect: [ :each | self class selector: each ].\x0a\x09runner := TestSuiteRunner on: suite.\x0a\x09self timeout: 200.\x0a\x09result := runner result.\x0a\x09assertBlock := self async: [\x0a\x09\x09self assert: (self selectorSetOf: result errors) equals: #('fakeError') asSet.\x0a\x09\x09self assert: (self selectorSetOf: result failures) equals: #('fakeErrorFailingInTearDown' 'fakeFailure') asSet.\x0a\x09\x09self finished\x0a\x09].\x0a\x09runner announcer on: ResultAnnouncement do: [ :ann |\x0a\x09\x09ann result == result ifTrue: [ result runs = result total ifTrue: assertBlock ] ].\x0a\x09runner run",
-messageSends: ["collect:", "selector:", "class", "on:", "timeout:", "result", "async:", "assert:equals:", "selectorSetOf:", "errors", "asSet", "failures", "finished", "on:do:", "announcer", "ifTrue:", "==", "=", "runs", "total", "run"],
 referencedClasses: ["TestSuiteRunner", "ResultAnnouncement"]
+//>>excludeEnd("ide");
 }),
 globals.SUnitAsyncTest);
 
@@ -435,30 +643,47 @@ protocol: 'tests',
 fn: function (){
 var self=this;
 function $Error(){return globals.Error||(typeof Error=="undefined"?nil:Error)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self._should_raise_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 return self._async_((function(){
 
 }));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["async:"]=1;
+//>>excludeEnd("ctx");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
 }),$Error());
 self._timeout_((0));
 self._shouldnt_raise_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 return self._async_((function(){
 
 }));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,3)});
+//>>excludeEnd("ctx");
 }),$Error());
 self._finished();
-return self}, function($ctx1) {$ctx1.fill(self,"testAsyncNeedsTimeout",{},globals.SUnitAsyncTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testAsyncNeedsTimeout",{},globals.SUnitAsyncTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["should:raise:", "async:", "timeout:", "shouldnt:raise:", "finished"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testAsyncNeedsTimeout\x0a\x09self should: [ self async: [ ] ] raise: Error.\x0a\x09self timeout: 0.\x0a\x09self shouldnt: [ self async: [ ] ] raise: Error.\x0a\x09self finished",
-messageSends: ["should:raise:", "async:", "timeout:", "shouldnt:raise:", "finished"],
 referencedClasses: ["Error"]
+//>>excludeEnd("ide");
 }),
 globals.SUnitAsyncTest);
 
@@ -469,25 +694,42 @@ protocol: 'tests',
 fn: function (){
 var self=this;
 function $Error(){return globals.Error||(typeof Error=="undefined"?nil:Error)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self._should_raise_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 return self._finished();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["finished"]=1;
+//>>excludeEnd("ctx");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
 }),$Error());
 self._timeout_((0));
 self._shouldnt_raise_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 return self._finished();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)});
+//>>excludeEnd("ctx");
 }),$Error());
-return self}, function($ctx1) {$ctx1.fill(self,"testFinishedNeedsTimeout",{},globals.SUnitAsyncTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testFinishedNeedsTimeout",{},globals.SUnitAsyncTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["should:raise:", "finished", "timeout:", "shouldnt:raise:"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testFinishedNeedsTimeout\x0a\x09self should: [ self finished ] raise: Error.\x0a\x09self timeout: 0.\x0a\x09self shouldnt: [ self finished ] raise: Error.",
-messageSends: ["should:raise:", "finished", "timeout:", "shouldnt:raise:"],
 referencedClasses: ["Error"]
+//>>excludeEnd("ide");
 }),
 globals.SUnitAsyncTest);
 
@@ -497,24 +739,37 @@ selector: "testIsAsyncReturnsCorrectValues",
 protocol: 'tests',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$2;
 $1=self._isAsync();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["isAsync"]=1;
+//>>excludeEnd("ctx");
 self._deny_($1);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["deny:"]=1;
+//>>excludeEnd("ctx");
 self._timeout_((0));
 $2=self._isAsync();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["isAsync"]=2;
+//>>excludeEnd("ctx");
 self._assert_($2);
 self._finished();
 self._deny_(self._isAsync());
-return self}, function($ctx1) {$ctx1.fill(self,"testIsAsyncReturnsCorrectValues",{},globals.SUnitAsyncTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testIsAsyncReturnsCorrectValues",{},globals.SUnitAsyncTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["deny:", "isAsync", "timeout:", "assert:", "finished"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testIsAsyncReturnsCorrectValues\x0a\x09self deny: self isAsync.\x0a\x09self timeout: 0.\x0a\x09self assert: self isAsync.\x0a\x09self finished.\x0a\x09self deny: self isAsync",
-messageSends: ["deny:", "isAsync", "timeout:", "assert:", "finished"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.SUnitAsyncTest);
 
@@ -524,23 +779,34 @@ selector: "testPass",
 protocol: 'tests',
 fn: function (){
 var self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self["@flag"]="bad";
 self._timeout_((10));
 self["@flag"]=_st(self._async_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 self._assert_(true);
 self._finished();
 self["@flag"]="ok";
 return self["@flag"];
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
 })))._valueWithTimeout_((5));
-return self}, function($ctx1) {$ctx1.fill(self,"testPass",{},globals.SUnitAsyncTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testPass",{},globals.SUnitAsyncTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["timeout:", "valueWithTimeout:", "async:", "assert:", "finished"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testPass\x0a\x09flag := 'bad'.\x0a\x09self timeout: 10.\x0a\x09flag := (self async: [ self assert: true. self finished. flag := 'ok' ]) valueWithTimeout: 5",
-messageSends: ["timeout:", "valueWithTimeout:", "async:", "assert:", "finished"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.SUnitAsyncTest);
 
@@ -554,43 +820,68 @@ var suite,runner,result,assertBlock;
 function $TestSuiteRunner(){return globals.TestSuiteRunner||(typeof TestSuiteRunner=="undefined"?nil:TestSuiteRunner)}
 function $Set(){return globals.Set||(typeof Set=="undefined"?nil:Set)}
 function $ResultAnnouncement(){return globals.ResultAnnouncement||(typeof ResultAnnouncement=="undefined"?nil:ResultAnnouncement)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$2,$3;
 suite=["fakeTimeout", "fakeMultipleTimeoutFailing", "fakeMultipleTimeoutPassing", "testPass"]._collect_((function(each){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 return _st(self._class())._selector_(each);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)});
+//>>excludeEnd("ctx");
 }));
 runner=_st($TestSuiteRunner())._on_(suite);
 self._timeout_((200));
 result=_st(runner)._result();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["result"]=1;
+//>>excludeEnd("ctx");
 assertBlock=self._async_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 $1=self._selectorSetOf_(_st(result)._errors());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["selectorSetOf:"]=1;
+//>>excludeEnd("ctx");
 self._assert_equals_($1,_st($Set())._new());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["assert:equals:"]=1;
+//>>excludeEnd("ctx");
 self._assert_equals_(self._selectorSetOf_(_st(result)._failures()),["fakeMultipleTimeoutFailing", "fakeTimeout"]._asSet());
 return self._finished();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)});
+//>>excludeEnd("ctx");
 }));
 _st(_st(runner)._announcer())._on_do_($ResultAnnouncement(),(function(ann){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 $2=_st(_st(ann)._result()).__eq_eq(result);
 if(smalltalk.assert($2)){
 $3=_st(_st(result)._runs()).__eq(_st(result)._total());
 return _st($3)._ifTrue_(assertBlock);
 };
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({ann:ann},$ctx1,3)});
+//>>excludeEnd("ctx");
 }));
 _st(runner)._run();
-return self}, function($ctx1) {$ctx1.fill(self,"testTimeouts",{suite:suite,runner:runner,result:result,assertBlock:assertBlock},globals.SUnitAsyncTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testTimeouts",{suite:suite,runner:runner,result:result,assertBlock:assertBlock},globals.SUnitAsyncTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["collect:", "selector:", "class", "on:", "timeout:", "result", "async:", "assert:equals:", "selectorSetOf:", "errors", "new", "failures", "asSet", "finished", "on:do:", "announcer", "ifTrue:", "==", "=", "runs", "total", "run"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testTimeouts\x0a\x09| suite runner result assertBlock |\x0a\x09suite := #('fakeTimeout' 'fakeMultipleTimeoutFailing' 'fakeMultipleTimeoutPassing' 'testPass') collect: [ :each | self class selector: each ].\x0a\x09runner := TestSuiteRunner on: suite.\x0a\x09self timeout: 200.\x0a\x09result := runner result.\x0a\x09assertBlock := self async: [\x0a\x09\x09self assert: (self selectorSetOf: result errors) equals: Set new.\x0a\x09\x09self assert: (self selectorSetOf: result failures) equals: #('fakeMultipleTimeoutFailing' 'fakeTimeout') asSet.\x0a\x09\x09self finished\x0a\x09].\x0a\x09runner announcer on: ResultAnnouncement do: [ :ann |\x0a\x09\x09ann result == result ifTrue: [ result runs = result total ifTrue: assertBlock ] ].\x0a\x09runner run",
-messageSends: ["collect:", "selector:", "class", "on:", "timeout:", "result", "async:", "assert:equals:", "selectorSetOf:", "errors", "new", "failures", "asSet", "finished", "on:do:", "announcer", "ifTrue:", "==", "=", "runs", "total", "run"],
 referencedClasses: ["TestSuiteRunner", "Set", "ResultAnnouncement"]
+//>>excludeEnd("ide");
 }),
 globals.SUnitAsyncTest);
 
@@ -601,43 +892,68 @@ protocol: 'tests',
 fn: function (){
 var self=this;
 var x;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
 self["@flag"]="bad";
 self._timeout_((10));
 x=(0);
 $1=self._async_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 self._finished();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["finished"]=1;
+//>>excludeEnd("ctx");
 self["@flag"]="ok";
 self["@flag"];
 x=_st(x).__plus((1));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["+"]=1;
+//>>excludeEnd("ctx");
 x;
 return self._assert_equals_(x,(1));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["assert:equals:"]=1;
+//>>excludeEnd("ctx");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
 }));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["async:"]=1;
+//>>excludeEnd("ctx");
 self["@flag"]=_st($1)._valueWithTimeout_((0));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["valueWithTimeout:"]=1;
+//>>excludeEnd("ctx");
 self["@flag"]=_st(self._async_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 return smalltalk.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 self._finished();
 self["@flag"]="ok";
 self["@flag"];
 x=_st(x).__plus((1));
 x;
 return self._assert_equals_(x,(1));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)});
+//>>excludeEnd("ctx");
 })))._valueWithTimeout_((0));
-return self}, function($ctx1) {$ctx1.fill(self,"testTwoAsyncPassesWithFinishedOnlyOneIsRun",{x:x},globals.SUnitAsyncTest)});
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testTwoAsyncPassesWithFinishedOnlyOneIsRun",{x:x},globals.SUnitAsyncTest)});
+//>>excludeEnd("ctx");
 },
+messageSends: ["timeout:", "valueWithTimeout:", "async:", "finished", "+", "assert:equals:"],
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testTwoAsyncPassesWithFinishedOnlyOneIsRun\x0a\x09| x |\x0a\x09flag := 'bad'.\x0a\x09self timeout: 10.\x0a\x09x := 0.\x0a\x09flag := (self async: [ self finished. flag := 'ok'. x := x+1. self assert: x equals: 1 ]) valueWithTimeout: 0.\x0a\x09flag := (self async: [ self finished. flag := 'ok'. x := x+1. self assert: x equals: 1 ]) valueWithTimeout: 0.",
-messageSends: ["timeout:", "valueWithTimeout:", "async:", "finished", "+", "assert:equals:"],
 referencedClasses: []
+//>>excludeEnd("ide");
 }),
 globals.SUnitAsyncTest);