fcl-js: no brackets in var-comma

git-svn-id: trunk@37578 -

packages/fcl-js/src/jswriter.pp

@@ -993,7 +993,12 @@ begin
     AllowCompact:=TJSBinaryExpression(El).AllowCompact;
     end;
   If Not (AllowCompact and (woCompact in Options)) then
-    S:=' '+S+' ';
+    begin
+    if El is TJSCommaExpression then
+      S:=S+' '
+    else
+      S:=' '+S+' ';
+    end;
   Write(S);
   WriteJS(El.B);
   Writer.CurElement:=El;
@@ -1449,6 +1454,7 @@ procedure TJSWriter.WriteVariableStatement(El: TJSVariableStatement);
 
 begin
   Write('var ');
+  FSkipRoundBrackets:=true;
   WriteJS(El.A);
 end;
 

packages/fcl-js/tests/tcwriter.pp

@@ -134,6 +134,7 @@ type
     Procedure TestForStatementFull;
     Procedure TestForStatementFull1;
     Procedure TestForStatementCompact;
+    Procedure TestForStatement2loops2inits;
     Procedure TestForInStatement;
     Procedure TestWhileStatement;
     Procedure TestDoWhileStatement;
@@ -751,7 +752,7 @@ end;
   TTestStatementWriter
   ---------------------------------------------------------------------}
 
-Procedure TTestStatementWriter.TestAssignment(Const Msg: String;
+procedure TTestStatementWriter.TestAssignment(const Msg: String;
   AClass: TJSAssignStatementClass; Result: String; ACompact: Boolean);
 Var
   U : TJSAssignStatement;
@@ -762,7 +763,7 @@ begin
   AssertWrite(Msg,Result,U);
 end;
 
-Function TTestStatementWriter.CreateAssignment(AClass: TJSAssignStatementClass
+function TTestStatementWriter.CreateAssignment(AClass: TJSAssignStatementClass
   ): TJSAssignStatement;
 begin
   if AClass=Nil then
@@ -785,37 +786,37 @@ begin
   Result.B:=CreateAssignment(nil);
 end;
 
-Procedure TTestStatementWriter.TestEmptyStatement;
+procedure TTestStatementWriter.TestEmptyStatement;
 
 begin
   AssertWrite('Empty statement','',TJSEmptyStatement.Create(0,0));
 end;
 
-Procedure TTestStatementWriter.TestEmptyStatementComment;
+procedure TTestStatementWriter.TestEmptyStatementComment;
 begin
   Writer.Options:=[woEmptyStatementAsComment,woUseUTF8];
   AssertWrite('Empty statement as comment','/* Empty statement */',TJSEmptyStatement.Create(0,0));
 end;
 
-Procedure TTestStatementWriter.TestEmptyStatementBlock;
+procedure TTestStatementWriter.TestEmptyStatementBlock;
 begin
   AssertWrite('Empty statement block','{'+sLineBreak+'}',TJSEmptyBlockStatement.Create(0,0));
 end;
 
-Procedure TTestStatementWriter.TestEmptyStatementBlockIndent;
+procedure TTestStatementWriter.TestEmptyStatementBlockIndent;
 begin
   Writer.IndentSize:=2;
   Writer.Indent;
   AssertWrite('Empty statement block','  {'+sLineBreak+'  }',TJSEmptyBlockStatement.Create(0,0));
 end;
 
-Procedure TTestStatementWriter.TestEmptyStatementBlockCompact;
+procedure TTestStatementWriter.TestEmptyStatementBlockCompact;
 begin
   Writer.Options:=[woCompact,woUseUTF8];
   AssertWrite('Empty statement block','{}',TJSEmptyBlockStatement.Create(0,0));
 end;
 
-Procedure TTestStatementWriter.TestVarDeclaration;
+procedure TTestStatementWriter.TestVarDeclaration;
 
 Var
   V : TJSVarDeclaration;
@@ -825,7 +826,7 @@ begin
   AssertWrite('simple var','a',V);
 end;
 
-Procedure TTestStatementWriter.TestVarDeclarationInit;
+procedure TTestStatementWriter.TestVarDeclarationInit;
 Var
   V : TJSVarDeclaration;
 begin
@@ -835,7 +836,7 @@ begin
   AssertWrite('simple var, init ','a = 1',V);
 end;
 
-Procedure TTestStatementWriter.TestVarListDeclaration;
+procedure TTestStatementWriter.TestVarListDeclaration;
 Var
   B,L : TJSVariableDeclarationList;
   V : TJSVarDeclaration;
@@ -854,7 +855,7 @@ begin
   AssertWrite('simple var list ','a, b = 1',L);
 end;
 
-Procedure TTestStatementWriter.TestVarListDeclarationInit;
+procedure TTestStatementWriter.TestVarListDeclarationInit;
 Var
   B,L : TJSVariableDeclarationList;
   V : TJSVarDeclaration;
@@ -873,7 +874,7 @@ begin
   AssertWrite('simple var list ','a, b',L);
 end;
 
-Procedure TTestStatementWriter.TestVarDeclarationStatement;
+procedure TTestStatementWriter.TestVarDeclarationStatement;
 
 Var
   S : TJSVariableStatement;
@@ -886,7 +887,7 @@ begin
   AssertWrite('simple var','var a',S);
 end;
 
-Procedure TTestStatementWriter.TestVarListDeclarationStatement;
+procedure TTestStatementWriter.TestVarListDeclarationStatement;
 
 Var
   S : TJSVariableStatement;
@@ -903,7 +904,7 @@ begin
   AssertWrite('simple var','var a',S);
 end;
 
-Procedure TTestStatementWriter.TestVarListDeclarationStatement2Vars;
+procedure TTestStatementWriter.TestVarListDeclarationStatement2Vars;
 Var
   S : TJSVariableStatement;
   V : TJSVarDeclaration;
@@ -924,7 +925,7 @@ begin
   AssertWrite('simple 2 vars','var a, b',S);
 end;
 
-Procedure TTestStatementWriter.TestReturnStatement;
+procedure TTestStatementWriter.TestReturnStatement;
 Var
   S : TJSReturnStatement;
 
@@ -934,7 +935,7 @@ begin
   AssertWrite('simple return','return a',S);
 end;
 
-Procedure TTestStatementWriter.TestLabeledStatement;
+procedure TTestStatementWriter.TestLabeledStatement;
 Var
   LS : TJSLabeledStatement;
   S : TJSReturnStatement;
@@ -949,7 +950,7 @@ begin
   AssertWrite('simple return','loc:'+sLineBreak+'return a',LS);
 end;
 
-Procedure TTestStatementWriter.TestLabeledStatementCompact;
+procedure TTestStatementWriter.TestLabeledStatementCompact;
 Var
   LS : TJSLabeledStatement;
   S : TJSReturnStatement;
@@ -965,7 +966,7 @@ begin
   AssertWrite('simple return','loc: return a',LS);
 end;
 
-Procedure TTestStatementWriter.TestContinueStatement;
+procedure TTestStatementWriter.TestContinueStatement;
 
 Var
   S : TJSContinueStatement;
@@ -975,7 +976,7 @@ begin
   AssertWrite('simple continue','continue',S);
 end;
 
-Procedure TTestStatementWriter.TestContinueTargetStatement;
+procedure TTestStatementWriter.TestContinueTargetStatement;
 
 Var
   S : TJSContinueStatement;
@@ -986,7 +987,7 @@ begin
   AssertWrite('continue a','continue a',S);
 end;
 
-Procedure TTestStatementWriter.TestBreakStatement;
+procedure TTestStatementWriter.TestBreakStatement;
 
 Var
   S : TJSBreakStatement;
@@ -996,7 +997,7 @@ begin
   AssertWrite('simple break','break',S);
 end;
 
-Procedure TTestStatementWriter.TestBreakTargetStatement;
+procedure TTestStatementWriter.TestBreakTargetStatement;
 Var
   S : TJSBreakStatement;
 
@@ -1006,127 +1007,127 @@ begin
   AssertWrite('simple break a','break a',S);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementSimple;
+procedure TTestStatementWriter.TestAssignmentStatementSimple;
 begin
   TestAssignment('Simple assignment',TJSSimpleAssignStatement,'a = b',False);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementSimpleCompact;
+procedure TTestStatementWriter.TestAssignmentStatementSimpleCompact;
 begin
   TestAssignment('Simple assignment',TJSSimpleAssignStatement,'a=b',True);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementAdd;
+procedure TTestStatementWriter.TestAssignmentStatementAdd;
 begin
   TestAssignment('Add assignment',TJSAddEqAssignStatement,'a += b',False);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementAddCompact;
+procedure TTestStatementWriter.TestAssignmentStatementAddCompact;
 begin
   TestAssignment('Add assignment',TJSAddEqAssignStatement,'a+=b',True);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementSubtract;
+procedure TTestStatementWriter.TestAssignmentStatementSubtract;
 begin
   TestAssignment('Subtract assignment',TJSSubEqAssignStatement,'a -= b',False);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementSubtractCompact;
+procedure TTestStatementWriter.TestAssignmentStatementSubtractCompact;
 begin
   TestAssignment('Subtract assignment',TJSSubEqAssignStatement,'a-=b',True);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementMultiply;
+procedure TTestStatementWriter.TestAssignmentStatementMultiply;
 begin
   TestAssignment('Multiply assignment',TJSMulEqAssignStatement,'a *= b',False);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementMultiplyCompact;
+procedure TTestStatementWriter.TestAssignmentStatementMultiplyCompact;
 begin
   TestAssignment('Multiply assignment',TJSMulEqAssignStatement,'a*=b',True);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementDivide;
+procedure TTestStatementWriter.TestAssignmentStatementDivide;
 begin
   TestAssignment('Divide assignment',TJSDivEqAssignStatement,'a /= b',False);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementDivideCompact;
+procedure TTestStatementWriter.TestAssignmentStatementDivideCompact;
 begin
   TestAssignment('Divide assignment',TJSDivEqAssignStatement,'a/=b',True);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementShift;
+procedure TTestStatementWriter.TestAssignmentStatementShift;
 begin
   TestAssignment('Shift assignment',TJSLShiftEqAssignStatement,'a <<= b',False);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementShiftCompact;
+procedure TTestStatementWriter.TestAssignmentStatementShiftCompact;
 begin
   TestAssignment('Shift assignment',TJSLShiftEqAssignStatement,'a<<=b',True);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementRShift;
+procedure TTestStatementWriter.TestAssignmentStatementRShift;
 begin
   TestAssignment('RShift assignment',TJSRShiftEqAssignStatement,'a >>= b',False);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementRShiftCompact;
+procedure TTestStatementWriter.TestAssignmentStatementRShiftCompact;
 begin
   TestAssignment('RShift assignment',TJSRShiftEqAssignStatement,'a>>=b',True);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementURShift;
+procedure TTestStatementWriter.TestAssignmentStatementURShift;
 begin
   TestAssignment('URShift assignment',TJSURShiftEqAssignStatement,'a >>>= b',False);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementURShiftCompact;
+procedure TTestStatementWriter.TestAssignmentStatementURShiftCompact;
 begin
   TestAssignment('URShift assignment',TJSURShiftEqAssignStatement,'a>>>=b',True);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementMod;
+procedure TTestStatementWriter.TestAssignmentStatementMod;
 begin
   TestAssignment('Mod assignment',TJSModEqAssignStatement,'a %= b',False);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementModCompact;
+procedure TTestStatementWriter.TestAssignmentStatementModCompact;
 begin
   TestAssignment('Mod assignment',TJSModEqAssignStatement,'a%=b',True);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementBinaryOr;
+procedure TTestStatementWriter.TestAssignmentStatementBinaryOr;
 begin
   TestAssignment('Binary or assignment',TJSOrEqAssignStatement,'a |= b',False);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementBinaryOrCompact;
+procedure TTestStatementWriter.TestAssignmentStatementBinaryOrCompact;
 begin
   TestAssignment('Binary or assignment',TJSOrEqAssignStatement,'a |= b',False);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementBinaryXOr;
+procedure TTestStatementWriter.TestAssignmentStatementBinaryXOr;
 begin
   TestAssignment('Binary xor assignment',TJSXOrEqAssignStatement,'a ^= b',False);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementBinaryXOrCompact;
+procedure TTestStatementWriter.TestAssignmentStatementBinaryXOrCompact;
 begin
   TestAssignment('Binary xor assignment',TJSXOrEqAssignStatement,'a^=b',True);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementBinaryAnd;
+procedure TTestStatementWriter.TestAssignmentStatementBinaryAnd;
 begin
   TestAssignment('Binary and assignment',TJSAndEqAssignStatement,'a &= b',False);
 end;
 
-Procedure TTestStatementWriter.TestAssignmentStatementBinaryAndCompact;
+procedure TTestStatementWriter.TestAssignmentStatementBinaryAndCompact;
 begin
   TestAssignment('Binary and assignment',TJSAndEqAssignStatement,'a&=b',True);
 end;
 
-Procedure TTestStatementWriter.TestForStatementEmpty;
+procedure TTestStatementWriter.TestForStatementEmpty;
 
 Var
   S : TJSForStatement;
@@ -1136,7 +1137,7 @@ begin
   AssertWrite('neverending for','for (; ; ) {'+sLineBreak+'}',S);
 end;
 
-Procedure TTestStatementWriter.TestForStatementFull;
+procedure TTestStatementWriter.TestForStatementFull;
 
 Var
   S : TJSForStatement;
@@ -1189,7 +1190,7 @@ begin
     +'}',S);
 end;
 
-Procedure TTestStatementWriter.TestForStatementCompact;
+procedure TTestStatementWriter.TestForStatementCompact;
 Var
   S : TJSForStatement;
   UPP : TJSUnaryPostPlusPlusExpression;
@@ -1214,7 +1215,72 @@ begin
   AssertWrite('for i:=0 to 9','for (i=0; i<10; i++) {}',S);
 end;
 
-Procedure TTestStatementWriter.TestForInStatement;
+procedure TTestStatementWriter.TestForStatement2loops2inits;
+var
+  L: TJSStatementList;
+
+  function CreateIdent(aName: string): TJSPrimaryExpressionIdent;
+  begin
+    Result:=TJSPrimaryExpressionIdent.Create(0,0);
+    Result.Name:=TJSString(aName);
+  end;
+
+  function CreateNumber(i: TJSNumber): TJSLiteral;
+  begin
+    Result:=TJSLiteral.Create(0,0);
+    Result.Value.AsNumber:=i;
+  end;
+
+  function CreateAssignSt(LHS, Expr: TJSElement): TJSSimpleAssignStatement;
+  begin
+    Result:=TJSSimpleAssignStatement.Create(0,0);
+    Result.LHS:=LHS;
+    Result.Expr:=Expr;
+  end;
+
+  function CreateFor(LoopVar, LoopEndVar: string; StartExpr, EndExpr: TJSElement;
+    Up: boolean; Target: string): TJSForStatement;
+  var
+    V: TJSVariableStatement;
+    C: TJSCommaExpression;
+  begin
+    Result:=TJSForStatement.Create(0,0);
+    V:=TJSVariableStatement.Create(0,0);
+    Result.Init:=V;
+    C:=TJSCommaExpression.Create(0,0);
+    V.A:=C;
+    C.A:=CreateAssignSt(CreateIdent(LoopVar),StartExpr);
+    C.B:=CreateAssignSt(CreateIdent(LoopEndVar),EndExpr);
+
+    if Up then
+      Result.Cond:=TJSRelationalExpressionLE.Create(0,0)
+    else
+      Result.Cond:=TJSRelationalExpressionGE.Create(0,0);
+    TJSRelationalExpression(Result.Cond).A:=CreateIdent(LoopVar);
+    TJSRelationalExpression(Result.Cond).B:=CreateIdent(LoopEndVar);
+
+    if Up then
+      Result.Incr:=TJSUnaryPostPlusPlusExpression.Create(0,0)
+    else
+      Result.Incr:=TJSUnaryPostMinusMinusExpression.Create(0,0);
+    TJSUnaryExpression(Result.Incr).A:=CreateIdent(LoopVar);
+
+    Result.Body:=CreateAssignSt(CreateIdent(Target),CreateIdent(LoopVar));
+  end;
+
+begin
+  L:=TJSStatementList.Create(0,0);
+  L.A:=CreateFor('$loop1','$loopend2',CreateNumber(3),CreateNumber(5),true,'$mod.i');
+  L.B:=CreateFor('$loop3','$loopend4',CreateNumber(10),CreateNumber(7),false,'$mod.i');
+  AssertWrite('for i:=3 to 5 do ; for i:=10 downto 7 do ;',
+    '{'+LineEnding
+    +'for (var $loop1 = 3, $loopend2 = 5; $loop1 <= $loopend2; $loop1++) $mod.i = $loop1;'+LineEnding
+    +'for (var $loop3 = 10, $loopend4 = 7; $loop3 >= $loopend4; $loop3--) $mod.i = $loop3;'+LineEnding
+    +'}'
+    ,L);
+end;
+
+procedure TTestStatementWriter.TestForInStatement;
 
 Var
   S : TJSForInStatement;
@@ -1227,7 +1293,7 @@ begin
   AssertWrite('for a in b','for (a in b) {'+sLineBreak+'}',S);
 end;
 
-Procedure TTestStatementWriter.TestWhileStatement;
+procedure TTestStatementWriter.TestWhileStatement;
 Var
   S : TJSWhileStatement;
 
@@ -1238,7 +1304,7 @@ begin
   AssertWrite('while a ','while (a) {'+sLineBreak+'}',S);
 end;
 
-Procedure TTestStatementWriter.TestDoWhileStatement;
+procedure TTestStatementWriter.TestDoWhileStatement;
 
 Var
   S : TJSDoWhileStatement;
@@ -1250,7 +1316,7 @@ begin
   AssertWrite('do while a ','do {'+sLineBreak+'} while (a)',S);
 end;
 
-Procedure TTestStatementWriter.TestSwitchStatementEmpty;
+procedure TTestStatementWriter.TestSwitchStatementEmpty;
 Var
   S : TJSSwitchStatement;
 
@@ -1260,7 +1326,7 @@ begin
   AssertWrite('switch ','switch (a) {'+sLineBreak+'}',S);
 end;
 
-Procedure TTestStatementWriter.TestSwitchStatementEmptyCompact;
+procedure TTestStatementWriter.TestSwitchStatementEmptyCompact;
 
 Var
   S : TJSSwitchStatement;
@@ -1272,7 +1338,7 @@ begin
   AssertWrite('switch ','switch (a) {}',S);
 end;
 
-Procedure TTestStatementWriter.TestSwitchStatementOneElement;
+procedure TTestStatementWriter.TestSwitchStatementOneElement;
 
 Var
   S : TJSSwitchStatement;
@@ -1287,7 +1353,7 @@ begin
   AssertWrite('switch ','switch (a) {'+sLineBreak+'case c:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'}',S);
 end;
 
-Procedure TTestStatementWriter.TestSwitchStatementOneElementCompact;
+procedure TTestStatementWriter.TestSwitchStatementOneElementCompact;
 Var
   S : TJSSwitchStatement;
   C : TJSCaseElement;
@@ -1301,7 +1367,7 @@ begin
   AssertWrite('switch ','switch (a) {case c: {}}',S);
 end;
 
-Procedure TTestStatementWriter.TestSwitchStatementTwoElements;
+procedure TTestStatementWriter.TestSwitchStatementTwoElements;
 Var
   S : TJSSwitchStatement;
   C : TJSCaseElement;
@@ -1318,7 +1384,7 @@ begin
   AssertWrite('switch ','switch (a) {'+sLineBreak+'case c:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'case d:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'}',S);
 end;
 
-Procedure TTestStatementWriter.TestSwitchStatementTwoElementsCompact;
+procedure TTestStatementWriter.TestSwitchStatementTwoElementsCompact;
 
 Var
   S : TJSSwitchStatement;
@@ -1336,7 +1402,7 @@ begin
   AssertWrite('switch ','switch (a) {case c: {} case d: {}}',S);
 end;
 
-Procedure TTestStatementWriter.TestSwitchStatementTwoElementsDefault;
+procedure TTestStatementWriter.TestSwitchStatementTwoElementsDefault;
 Var
   S : TJSSwitchStatement;
   C : TJSCaseElement;
@@ -1355,7 +1421,7 @@ begin
   AssertWrite('switch ','switch (a) {'+sLineBreak+'case c:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'case d:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'default:'+sLineBreak+'{'+sLineBreak+'}'+sLineBreak+'}',S);
 end;
 
-Procedure TTestStatementWriter.TestSwitchStatementTwoElementsDefaultCompact;
+procedure TTestStatementWriter.TestSwitchStatementTwoElementsDefaultCompact;
 Var
   S : TJSSwitchStatement;
   C : TJSCaseElement;
@@ -1375,7 +1441,7 @@ begin
   AssertWrite('switch ','switch (a) {case c: {} case d: {} default: {}}',S);
 end;
 
-Procedure TTestStatementWriter.TestSwitchStatementTwoElementsOneEmpty;
+procedure TTestStatementWriter.TestSwitchStatementTwoElementsOneEmpty;
 Var
   S : TJSSwitchStatement;
   C : TJSCaseElement;
@@ -1402,7 +1468,7 @@ begin
     +'}',S);
 end;
 
-Procedure TTestStatementWriter.TestSwitchStatementTwoElementsOneEmptyCompact;
+procedure TTestStatementWriter.TestSwitchStatementTwoElementsOneEmptyCompact;
 Var
   S : TJSSwitchStatement;
   C : TJSCaseElement;
@@ -1421,7 +1487,7 @@ begin
   AssertWrite('switch ','switch (a) {case c: case d: {} default: {}}',S);
 end;
 
-Procedure TTestStatementWriter.TestIfThen;
+procedure TTestStatementWriter.TestIfThen;
 Var
   S : TJSIfStatement;
 
@@ -1433,7 +1499,7 @@ begin
   AssertWrite('if then','if (a) {'+sLineBreak+'}',S);
 end;
 
-Procedure TTestStatementWriter.TestIfThenElse;
+procedure TTestStatementWriter.TestIfThenElse;
 Var
   S : TJSIfStatement;
 
@@ -1449,7 +1515,7 @@ begin
     +'}',S);
 end;
 
-Procedure TTestStatementWriter.TestStatementListEmpty;
+procedure TTestStatementWriter.TestStatementListEmpty;
 Var
   S : TJSStatementList;
 
@@ -1459,7 +1525,7 @@ begin
   AssertWrite('Statement list','{'+sLineBreak+'}',S);
 end;
 
-Procedure TTestStatementWriter.TestStatementListEmptyCompact;
+procedure TTestStatementWriter.TestStatementListEmptyCompact;
 Var
   S : TJSStatementList;
 
@@ -1469,7 +1535,7 @@ begin
   AssertWrite('Statement list','{}',S);
 end;
 
-Procedure TTestStatementWriter.TestStatementListOneStatement;
+procedure TTestStatementWriter.TestStatementListOneStatement;
 Var
   S : TJSStatementList;
 begin
@@ -1482,7 +1548,7 @@ begin
     +'}',S);
 end;
 
-Procedure TTestStatementWriter.TestStatementListOneStatementCompact;
+procedure TTestStatementWriter.TestStatementListOneStatementCompact;
 
 Var
   S : TJSStatementList;
@@ -1494,7 +1560,7 @@ begin
   AssertWrite('Statement list','{a=b}',S);
 end;
 
-Procedure TTestStatementWriter.TestStatementListTwoStatements;
+procedure TTestStatementWriter.TestStatementListTwoStatements;
 Var
   S : TJSStatementList;
 
@@ -1510,7 +1576,7 @@ begin
     +'}',S);
 end;
 
-Procedure TTestStatementWriter.TestStatementListTwoStatementsCompact;
+procedure TTestStatementWriter.TestStatementListTwoStatementsCompact;
 Var
   S : TJSStatementList;
 
@@ -1537,7 +1603,7 @@ begin
     +'}',S);
 end;
 
-Procedure TTestStatementWriter.TestEmptyFunctionDef;
+procedure TTestStatementWriter.TestEmptyFunctionDef;
 
 Var
   FD : TJSFunctionDeclarationStatement;
@@ -1551,7 +1617,7 @@ begin
     +'}',FD);
 end;
 
-Procedure TTestStatementWriter.TestEmptyFunctionDefCompact;
+procedure TTestStatementWriter.TestEmptyFunctionDefCompact;
 
 Var
   FD : TJSFunctionDeclarationStatement;
@@ -1564,7 +1630,7 @@ begin
   AssertWrite('Empty function, compact','function a() {}',FD);
 end;
 
-Procedure TTestStatementWriter.TestFunctionDefParams;
+procedure TTestStatementWriter.TestFunctionDefParams;
 Var
   FD : TJSFunctionDeclarationStatement;
 
@@ -1582,7 +1648,7 @@ begin
     +'}',FD);
 end;
 
-Procedure TTestStatementWriter.TestFunctionDefParamsCompact;
+procedure TTestStatementWriter.TestFunctionDefParamsCompact;
 
 Var
   FD : TJSFunctionDeclarationStatement;
@@ -1598,7 +1664,7 @@ begin
   AssertWrite('Empty function, 3 params, compact','function a(b,c,d) {}',FD);
 end;
 
-Procedure TTestStatementWriter.TestFunctionDefBody1;
+procedure TTestStatementWriter.TestFunctionDefBody1;
 
 Var
   FD : TJSFunctionDeclarationStatement;
@@ -1620,7 +1686,7 @@ begin
     +'}',FD);
 end;
 
-Procedure TTestStatementWriter.TestFunctionDefBody1Compact;
+procedure TTestStatementWriter.TestFunctionDefBody1Compact;
 Var
   FD : TJSFunctionDeclarationStatement;
   R : TJSReturnStatement;
@@ -1638,7 +1704,7 @@ begin
   AssertWrite('1 statement, compact','function a() {return 0; }',FD);
 end;
 
-Procedure TTestStatementWriter.TestFunctionDefBody2;
+procedure TTestStatementWriter.TestFunctionDefBody2;
 Var
   FD : TJSFunctionDeclarationStatement;
   R : TJSReturnStatement;
@@ -1673,7 +1739,7 @@ begin
     +'}',FD);
 end;
 
-Procedure TTestStatementWriter.TestFunctionDefBody2Compact;
+procedure TTestStatementWriter.TestFunctionDefBody2Compact;
 Var
   FD : TJSFunctionDeclarationStatement;
   R : TJSReturnStatement;
@@ -1704,7 +1770,7 @@ begin
   AssertWrite('Function, 2 statements, compact','function a(b) {b=b*10; return b}',FD);
 end;
 
-Procedure TTestStatementWriter.TestTryCatch;
+procedure TTestStatementWriter.TestTryCatch;
 
 Var
   T : TJSTryCatchStatement;
@@ -1734,7 +1800,7 @@ begin
     +'}',T);
 end;
 
-Procedure TTestStatementWriter.TestTryCatchCompact;
+procedure TTestStatementWriter.TestTryCatchCompact;
 Var
   T : TJSTryCatchStatement;
   A : TJSAssignStatement;
@@ -1759,7 +1825,7 @@ begin
   AssertWrite('Try catch compact','try {b=b*10} catch (e) {b=1}',T);
 end;
 
-Procedure TTestStatementWriter.TestTryFinally;
+procedure TTestStatementWriter.TestTryFinally;
 
 Var
   T : TJSTryFinallyStatement;
@@ -1789,7 +1855,7 @@ begin
    +'}',T);
 end;
 
-Procedure TTestStatementWriter.TestTryFinallyCompact;
+procedure TTestStatementWriter.TestTryFinallyCompact;
 
 Var
   T : TJSTryFinallyStatement;
@@ -1815,7 +1881,7 @@ begin
   AssertWrite('Try finally compact','try {b=b*10} finally {b=1}',T);
 end;
 
-Procedure TTestStatementWriter.TestTryCatchFinally;
+procedure TTestStatementWriter.TestTryCatchFinally;
 Var
   T : TJSTryCatchFinallyStatement;
   A : TJSAssignStatement;
@@ -1849,7 +1915,7 @@ begin
     +'  b = 1'+sLineBreak+'}',T);
 end;
 
-Procedure TTestStatementWriter.TestTryCatchFinallyCompact;
+procedure TTestStatementWriter.TestTryCatchFinallyCompact;
 Var
   T : TJSTryCatchFinallyStatement;
   A : TJSAssignStatement;
@@ -1878,7 +1944,7 @@ begin
   AssertWrite('Try finally ','try {b=b*10} catch (e) {b=10} finally {b=1}',T);
 end;
 
-Procedure TTestStatementWriter.TestWith;
+procedure TTestStatementWriter.TestWith;
 Var
   T : TJSWithStatement;
   A : TJSAssignStatement;
@@ -1899,7 +1965,7 @@ begin
   AssertWrite('With statement ','with (e)'+slineBreak+'  b = b * 10',T);
 end;
 
-Procedure TTestStatementWriter.TestWithCompact;
+procedure TTestStatementWriter.TestWithCompact;
 Var
   T : TJSWithStatement;
   A : TJSAssignStatement;
@@ -1920,7 +1986,7 @@ begin
   AssertWrite('With statement ','with (e) b=b*10',T);
 end;
 
-Procedure TTestStatementWriter.TestSourceElements;
+procedure TTestStatementWriter.TestSourceElements;
 Var
   T : TJSSourceElements;
   A : TJSAssignStatement;
@@ -1947,7 +2013,7 @@ begin
   AssertWrite('Statement lists ','b = b * 10;'+sLineBreak+'c = c * 2;'+sLineBreak,T);
 end;
 
-Procedure TTestStatementWriter.TestSourceElementsCompact;
+procedure TTestStatementWriter.TestSourceElementsCompact;
 Var
   T : TJSSourceElements;
   A : TJSAssignStatement;
@@ -2466,18 +2532,36 @@ Procedure TTestJSWriter.AssertResult(Const Msg, Result: String);
 
 Var
   S : AnsiString;
+  p: Integer;
 begin
   S:=FTextWriter.AsAnsistring;
-  AssertEquals(Msg,Result,S);
+  if S=Result then exit;
+  p:=1;
+  while (p<=length(S)) and (p<=length(Result)) and (S[p]=Result[p]) do inc(p);
+  if p>length(S) then
+    AssertEquals(Msg+' (actual too short)',Result,S)
+  else if p>length(Result) then
+    AssertEquals(Msg+' (actual too long)',Result,S)
+  else
+    AssertEquals(Msg+' (diff at '+IntToStr(p)+' "'+S[p]+'")',Result,S);
 end;
 
 Procedure TTestJSWriter.AssertResult(Const Msg: string; Result: UnicodeString);
 
 Var
   S : UnicodeString;
+  p: Integer;
 begin
   S:=FTextWriter.AsUnicodeString;
-  AssertEquals(Msg,String(Result),String(S));
+  if S=Result then exit;
+  p:=1;
+  while (p<=length(S)) and (p<=length(Result)) and (S[p]=Result[p]) do inc(p);
+  if p>length(S) then
+    AssertEquals(Msg+' (actual too short)',String(Result),String(S))
+  else if p>length(Result) then
+    AssertEquals(Msg+' (actual too long)',String(Result),String(S))
+  else
+    AssertEquals(Msg+' (diff at '+IntToStr(p)+' "'+String(S[p])+'")',String(Result),String(S));
 end;
 
 Procedure TTestJSWriter.AssertWrite(Const Msg, Result: String;