* Initial support for inline comment documentation

git-svn-id: trunk@29615 -

packages/fcl-passrc/src/pastree.pp

@@ -105,6 +105,7 @@ type
   TPasElement = class(TPasElementBase)
   private
     FData: TObject;
+    FDocComment: String;
     FRefCount: LongWord;
     FName: string;
     FParent: TPasElement;
@@ -133,6 +134,7 @@ type
     Property Hints : TPasMemberHints Read FHints Write FHints;
     Property CustomData : TObject Read FData Write FData;
     Property HintMessage : String Read FHintMessage Write FHintMessage;
+    Property DocComment : String Read FDocComment Write FDocComment;
   end;
 
   TPasExprKind = (pekIdent, pekNumber, pekString, pekSet, pekNil, pekBoolConst, pekRange,
@@ -1306,7 +1308,7 @@ end;
 
 function TPasElement.ElementTypeName: string; begin Result := SPasTreeElement end;
 
-function TPasElement.HintsString: String;
+Function TPasElement.HintsString: String;
 
 Var
   H : TPasmemberHint;
@@ -1567,7 +1569,7 @@ begin
   end;
 end;
 
-function TPasElement.GetDeclaration (full : boolean): string;
+function TPasElement.GetDeclaration(full: Boolean): string;
 
 begin
   if Full then

packages/fcl-passrc/src/pparser.pp

@@ -68,11 +68,14 @@ type
   TPasParserLogHandler = Procedure (Sender : TObject; Const Msg : String) of object;
   TPParserLogEvent = (pleInterface,pleImplementation);
   TPParserLogEvents = set of TPParserLogEvent;
+  TPasParser = Class;
 
   { TPasTreeContainer }
 
   TPasTreeContainer = class
   private
+    FCurrentParser: TPasParser;
+    FNeedComments: Boolean;
     FOnLog: TPasParserLogHandler;
     FPParserLogEvents: TPParserLogEvents;
     FScannerLogEvents: TPScannerLogEvents;
@@ -97,6 +100,8 @@ type
     Property ScannerLogEvents : TPScannerLogEvents Read FScannerLogEvents Write FScannerLogEvents;
     Property ParserLogEvents : TPParserLogEvents Read FPParserLogEvents Write FPParserLogEvents;
     Property OnLog : TPasParserLogHandler Read FOnLog Write FOnLog;
+    Property CurrentParser : TPasParser Read FCurrentParser;
+    Property NeedComments : Boolean Read FNeedComments Write FNeedComments;
   end;
 
   EParserError = class(Exception)
@@ -131,9 +136,12 @@ type
     FEngine: TPasTreeContainer;
     FCurToken: TToken;
     FCurTokenString: String;
+    FCurComments : TStrings;
+    FSavedComments : String;
     // UngetToken support:
     FTokenBuffer: array[0..1] of TToken;
     FTokenStringBuffer: array[0..1] of String;
+    FCommentsBuffer: array[0..1] of TStrings;
     FTokenBufferIndex: Integer; // current index in FTokenBuffer
     FTokenBufferSize: Integer; // maximum valid index in FTokenBuffer
     FDumpIndent : String;
@@ -146,6 +154,8 @@ type
     procedure ParseClassLocalTypes(AType: TPasClassType; AVisibility: TPasMemberVisibility);
     procedure ParseVarList(Parent: TPasElement; VarList: TFPList; AVisibility: TPasMemberVisibility; Full: Boolean);
   protected
+    Function SaveComments : String;
+    Function SaveComments(Const AValue : String) : String;
     function LogEvent(E : TPParserLogEvent) : Boolean; inline;
     Procedure DoLog(Const Msg : String; SkipSourceInfo : Boolean = False);overload;
     Procedure DoLog(Const Fmt : String; Args : Array of const;SkipSourceInfo : Boolean = False);overload;
@@ -182,9 +192,12 @@ type
     function  CheckIfOverloaded(AParent: TPasElement; const AName: String): TPasElement;
   public
     constructor Create(AScanner: TPascalScanner; AFileResolver: TBaseFileResolver;  AEngine: TPasTreeContainer);
+    Destructor Destroy; override;
     // General parsing routines
     function CurTokenName: String;
     function CurTokenText: String;
+    Function CurComments : TStrings;
+    Function SavedComments : String;
     procedure NextToken; // read next non whitespace, non space
     procedure UngetToken;
     procedure CheckToken(tk: TToken);
@@ -539,6 +552,23 @@ begin
   FScanner := AScanner;
   FFileResolver := AFileResolver;
   FEngine := AEngine;
+  FCommentsBuffer[0]:=TStringList.Create;
+  FCommentsBuffer[1]:=TStringList.Create;
+  if Assigned(FEngine) then
+    begin
+    FEngine.FCurrentParser:=Self;
+    If FEngine.NeedComments then
+      FScanner.SkipComments:=Not FEngine.NeedComments;
+    end;
+end;
+
+Destructor TPasParser.Destroy;
+begin
+  FreeAndNil(FCommentsBuffer[0]);
+  FreeAndNil(FCommentsBuffer[1]);
+  if Assigned(FEngine) then
+    FEngine.FCurrentParser:=Nil;
+  inherited Destroy;
 end;
 
 function TPasParser.CurTokenName: String;
@@ -559,13 +589,27 @@ begin
   end;
 end;
 
+Function TPasParser.CurComments: TStrings;
+begin
+  Result:=FCurComments;
+end;
+
+Function TPasParser.SavedComments: String;
+begin
+  Result:=FSavedComments;
+end;
+
 procedure TPasParser.NextToken;
+
+Var
+  T : TStrings;
 begin
   if FTokenBufferIndex < FTokenBufferSize then
   begin
     // Get token from buffer
     FCurToken := FTokenBuffer[FTokenBufferIndex];
     FCurTokenString := FTokenStringBuffer[FTokenBufferIndex];
+    FCurComments:=FCommentsBuffer[FTokenBufferIndex];
     Inc(FTokenBufferIndex);
     //writeln('TPasParser.NextToken From Buf ',CurTokenText,' id=',FTokenBufferIndex);
   end else
@@ -573,16 +617,22 @@ begin
     { We have to fetch a new token. But first check, wether there is space left
       in the token buffer.}
     if FTokenBufferSize = 2 then
-    begin
+      begin
       FTokenBuffer[0] := FTokenBuffer[1];
       FTokenStringBuffer[0] := FTokenStringBuffer[1];
+      T:=FCommentsBuffer[0];
+      FCommentsBuffer[0]:=FCommentsBuffer[1];
+      FCommentsBuffer[1]:=T;
       Dec(FTokenBufferSize);
       Dec(FTokenBufferIndex);
-    end;
+      end;
     // Fetch new token
     try
+      FCommentsBuffer[FTokenBufferSize].Clear;
       repeat
         FCurToken := Scanner.FetchToken;
+        if FCurToken=tkComment then
+          FCommentsBuffer[FTokenBufferSize].Add(Scanner.CurTokenString);
       until not (FCurToken in WhitespaceTokensToIgnore);
     except
       on e: EScannerError do
@@ -592,9 +642,10 @@ begin
     FCurTokenString := Scanner.CurTokenString;
     FTokenBuffer[FTokenBufferSize] := FCurToken;
     FTokenStringBuffer[FTokenBufferSize] := FCurTokenString;
+    FCurComments:=FCommentsBuffer[FTokenBufferSize];
     Inc(FTokenBufferSize);
     Inc(FTokenBufferIndex);
-    //writeln('TPasParser.NextToken New ',CurTokenText,' id=',FTokenBufferIndex);
+  //  writeln('TPasParser.NextToken New ',CurTokenText,' id=',FTokenBufferIndex,' comments = ',FCurComments.text);
   end;
 end;
 
@@ -609,9 +660,11 @@ begin
     begin
       FCurToken := FTokenBuffer[FTokenBufferIndex-1];
       FCurTokenString := FTokenStringBuffer[FTokenBufferIndex-1];
+      FCurComments:=FCommentsBuffer[FTokenBufferIndex-1];
     end else begin
       FCurToken := tkWhitespace;
       FCurTokenString := '';
+      FCurComments.Clear;
     end;
     //writeln('TPasParser.UngetToken ',CurTokenText,' id=',FTokenBufferIndex);
   end;
@@ -636,7 +689,7 @@ begin
   Result := CurTokenString;
 end;
 
-function TPasParser.CurTokenIsIdentifier(Const S: String): Boolean;
+Function TPasParser.CurTokenIsIdentifier(Const S: String): Boolean;
 begin
   Result:=(Curtoken=tkidentifier) and (CompareText(S,CurtokenText)=0);
 end;
@@ -658,13 +711,14 @@ begin
   Result:=IsCurTokenHint(dummy);
 end;
 
-function TPasParser.TokenIsCallingConvention(S: String;
-  out CC: TCallingConvention): Boolean;
+Function TPasParser.TokenIsCallingConvention(S: String; out
+  CC: TCallingConvention): Boolean;
 begin
   Result:=IsCallingConvention(S,CC);
 end;
 
-function TPasParser.TokenIsProcedureModifier(Parent : TPasElement; S: String; out Pm: TProcedureModifier): Boolean;
+Function TPasParser.TokenIsProcedureModifier(Parent: TPasElement; S: String;
+  Out Pm: TProcedureModifier): Boolean;
 begin
   Result:=IsModifier(S,PM);
   if result and (pm in [pmPublic,pmForward]) then
@@ -707,7 +761,7 @@ begin
     ExpectToken(tkSemiColon);
 end;
 
-Function TPasParser.CheckPackMode :  TPackMode;
+function TPasParser.CheckPackMode: TPackMode;
 
 begin
   NextToken;
@@ -750,7 +804,8 @@ begin
     AName:=SimpleTypeCaseNames[I];
 end;
 
-function TPasParser.ParseStringType(Parent : TPasElement; Const TypeName : String) : TPasAliasType;
+function TPasParser.ParseStringType(Parent: TPasElement; const TypeName: String
+  ): TPasAliasType;
 
 Var
   S : String;
@@ -878,17 +933,20 @@ begin
   end;
 end;
 
-function TPasParser.ParseEnumType(Parent : TPasElement; Const TypeName : String) : TPasEnumType;
+function TPasParser.ParseEnumType(Parent: TPasElement; const TypeName: String
+  ): TPasEnumType;
 
 Var
   EnumValue: TPasEnumValue;
 
 begin
+  Writeln('Current comments : ',SavedComments);
   Result := TPasEnumType(CreateElement(TPasEnumType, TypeName, Parent));
   try
     while True do
       begin
       NextToken;
+      SaveComments;
       EnumValue := TPasEnumValue(CreateElement(TPasEnumValue, CurTokenString, Result));
       Result.Values.Add(EnumValue);
       NextToken;
@@ -913,7 +971,8 @@ begin
   end;
 end;
 
-function TPasParser.ParseSetType(Parent: TPasElement; Const TypeName : String): TPasSetType;
+function TPasParser.ParseSetType(Parent: TPasElement; const TypeName: String
+  ): TPasSetType;
 
 begin
   Result := TPasSetType(CreateElement(TPasSetType, TypeName, Parent));
@@ -1558,7 +1617,8 @@ begin
   end;
 end;
 
-Function TPasParser.CheckOverloadList(AList : TFPList; AName : String; Out OldMember : TPasElement) : TPasOverloadedProc;
+function TPasParser.CheckOverloadList(AList: TFPList; AName: String; out
+  OldMember: TPasElement): TPasOverloadedProc;
 
 Var
   I : Integer;
@@ -1578,6 +1638,8 @@ begin
         Result:=TPasOverloadedProc.Create(AName, OldMember.Parent);
         Result.Visibility:=OldMember.Visibility;
         Result.Overloads.Add(OldMember);
+        Result.SourceFilename:=OldMember.SourceFilename;
+        Result.SourceLinenumber:=OldMember.SourceLinenumber;
         AList[i] := Result;
         end;
       end;
@@ -1638,6 +1700,7 @@ procedure TPasParser.ParseMain(var Module: TPasModule);
 begin
   Module:=nil;
   NextToken;
+  SaveComments;
   case CurToken of
     tkUnit:
       ParseUnit(Module);
@@ -1836,7 +1899,8 @@ begin
   UngetToken;
 end;
 
-Function TPasParser.GetProcTypeFromToken(tk : TToken; IsClass : Boolean = False) : TProcType;
+function TPasParser.GetProcTypeFromToken(tk: TToken; IsClass: Boolean
+  ): TProcType;
 
 begin
   Case tk of
@@ -1942,12 +2006,14 @@ begin
         CurBlock := declProperty;
       tkProcedure, tkFunction, tkConstructor, tkDestructor,tkOperator:
         begin
+        SaveComments;
         pt:=GetProcTypeFromToken(CurToken);
         AddProcOrFunction(Declarations, ParseProcedureOrFunctionDecl(Declarations, pt));
         CurBlock := declNone;
         end;
       tkClass:
         begin
+          SaveComments;
           NextToken;
           If CurToken in [tkprocedure,tkFunction,tkConstructor, tkDestructor] then
             begin
@@ -1960,6 +2026,7 @@ begin
         end;
       tkIdentifier:
         begin
+          SaveComments;
           case CurBlock of
             declConst:
               begin
@@ -2153,6 +2220,7 @@ end;
 // Starts after the variable name
 function TPasParser.ParseConstDecl(Parent: TPasElement): TPasConst;
 begin
+  SaveComments;
   Result := TPasConst(CreateElement(TPasConst, CurTokenString, Parent));
   try
     NextToken;
@@ -2174,6 +2242,7 @@ end;
 // Starts after the variable name
 function TPasParser.ParseResourcestringDecl(Parent: TPasElement): TPasResString;
 begin
+  SaveComments;
   Result := TPasResString(CreateElement(TPasResString, CurTokenString, Parent));
   try
     ExpectToken(tkEqual);
@@ -2205,7 +2274,8 @@ begin
 end;
 
 // Starts after the type name
-Function TPasParser.ParseRangeType(AParent : TPasElement; Const TypeName : String; Full : Boolean = True) : TPasRangeType;
+function TPasParser.ParseRangeType(AParent: TPasElement;
+  Const TypeName: String; Full: Boolean): TPasRangeType;
 
 Var
   PE : TPasExpr;
@@ -2259,7 +2329,8 @@ begin
   until (CurToken=tkSemicolon);
 end;
 
-Function TPasParser.ParseSpecializeType(Parent : TPasElement; Const TypeName : String) : TPasClassType;
+function TPasParser.ParseSpecializeType(Parent: TPasElement;
+  Const TypeName: String): TPasClassType;
 
 begin
   Result := TPasClassType(Engine.CreateElement(TPasClassType, TypeName, Parent, Scanner.CurFilename, Scanner.CurRow));
@@ -2274,7 +2345,8 @@ begin
   end;
 end;
 
-Function TPasParser.ParseProcedureType(Parent : TPasElement; Const TypeName : String; Const PT : TProcType) : TPasProcedureType;
+function TPasParser.ParseProcedureType(Parent: TPasElement;
+  const TypeName: String; const PT: TProcType): TPasProcedureType;
 
 begin
   if PT in [ptFunction,ptClassFunction] then
@@ -2299,7 +2371,8 @@ begin
   Result:=ParseType(Parent,TypeName,True);
 end;
 
-Function TPasParser.GetVariableValueAndLocation(Parent : TPasElement; out Value : TPasExpr; Out Location : String) : Boolean;
+function TPasParser.GetVariableValueAndLocation(Parent: TPasElement; Out
+  Value: TPasExpr; Out Location: String): Boolean;
 
 begin
   Value:=Nil;
@@ -2329,7 +2402,8 @@ begin
     UngetToken;
 end;
 
-Function TPasParser.GetVariableModifiers(Out Varmods : TVariableModifiers; Out Libname,ExportName : string) : string;
+function TPasParser.GetVariableModifiers(Out VarMods: TVariableModifiers; Out
+  Libname, ExportName: string): string;
 
 Var
   S : String;
@@ -2399,11 +2473,12 @@ var
   VarEl: TPasVariable;
   H : TPasMemberHints;
   varmods: TVariableModifiers;
-  Mods,Loc,alibname,aexpname : string;
+  D,Mods,Loc,alibname,aexpname : string;
 
 begin
   VarNames := TStringList.Create;
   try
+    D:=SaveComments; // This means we support only one comment per 'list'.
     Repeat
       VarNames.Add(CurTokenString);
       NextToken;
@@ -2425,6 +2500,7 @@ begin
       Mods:=GetVariableModifiers(varmods,alibname,aexpname)
     else
       NextToken;
+    SaveComments(D);
     for i := 0 to VarNames.Count - 1 do
       begin
       VarEl:=TPasVariable(CreateElement(TPasVariable,VarNames[i],Parent,AVisibility));
@@ -2450,12 +2526,25 @@ begin
   end;
 end;
 
+Function TPasParser.SaveComments: String;
+begin
+  if Engine.NeedComments then
+    FSavedComments:=CurComments.Text; // Expensive, so don't do unless needed.
+  Result:=FSavedComments;
+end;
+
+Function TPasParser.SaveComments(Const AValue: String): String;
+begin
+  FSavedComments:=AValue;
+  Result:=FSavedComments;
+end;
+
 function TPasParser.LogEvent(E: TPParserLogEvent): Boolean;
 begin
   Result:=E in FLogEvents;
 end;
 
-procedure TPasParser.DoLog(const Msg: String; SkipSourceInfo: Boolean);
+Procedure TPasParser.DoLog(Const Msg: String; SkipSourceInfo: Boolean);
 begin
   If Assigned(FOnLog) then
     if SkipSourceInfo or not assigned(scanner) then
@@ -2464,7 +2553,7 @@ begin
       FOnLog(Self,Format('%s(%d) : %s',[Scanner.CurFilename,SCanner.CurRow,Msg]));
 end;
 
-procedure TPasParser.DoLog(const Fmt: String; Args: array of const;
+Procedure TPasParser.DoLog(Const Fmt: String; Args: Array of const;
   SkipSourceInfo: Boolean);
 begin
   DoLog(Format(Fmt,Args),SkipSourceInfo);
@@ -2595,7 +2684,8 @@ begin
 end;
 
 
-Function TPasParser.CheckProcedureArgs(Parent  : TPasElement; Args : TFPList; Mandatory : Boolean) : boolean;
+function TPasParser.CheckProcedureArgs(Parent: TPasElement; Args: TFPList;
+  Mandatory: Boolean): boolean;
 
 begin
   NextToken;
@@ -3500,7 +3590,7 @@ begin
 end;
 
 // Starts after the "procedure" or "function" token
-Function TPasParser.GetProcedureClass(ProcType : TProcType) : TPTreeElement;
+function TPasParser.GetProcedureClass(ProcType: TProcType): TPTreeElement;
 
 begin
   Case ProcType of
@@ -3567,7 +3657,8 @@ begin
 end;
 
 // Current token is the first token after tkOf
-Procedure TPasParser.ParseRecordVariantParts(ARec : TPasRecordType; AEndToken: TToken);
+procedure TPasParser.ParseRecordVariantParts(ARec: TPasRecordType;
+  AEndToken: TToken);
 
 Var
   M : TPasRecordType;
@@ -3613,7 +3704,8 @@ begin
 end;
 
 // Starts on first token after Record or (. Ends on AEndToken
-Procedure TPasParser.ParseRecordFieldList(ARec : TPasRecordType; AEndToken : TToken; AllowMethods : Boolean);
+procedure TPasParser.ParseRecordFieldList(ARec: TPasRecordType;
+  AEndToken: TToken; AllowMethods: Boolean);
 
 Var
   VN : String;
@@ -3626,6 +3718,7 @@ begin
   v:=visPublic;
   while CurToken<>AEndToken do
     begin
+    SaveComments;
     Case CurToken of
       tkProperty:
         begin
@@ -3722,7 +3815,8 @@ begin
     end;
 end;
 
-Function TPasParser.CheckVisibility(S : String; Var AVisibility :TPasMemberVisibility) : Boolean;
+function TPasParser.CheckVisibility(S: String;
+  var AVisibility: TPasMemberVisibility): Boolean;
 
 Var
   B : Boolean;
@@ -3764,7 +3858,8 @@ begin
     AType.Members.Add(Proc);
 end;
 
-procedure TPasParser.ParseClassFields(AType: TPasClassType; Const AVisibility : TPasMemberVisibility; IsClassField : Boolean);
+procedure TPasParser.ParseClassFields(AType: TPasClassType;
+  const AVisibility: TPasMemberVisibility; IsClassField: Boolean);
 
 Var
   VarList: TFPList;
@@ -3839,11 +3934,13 @@ begin
       tkType:
         begin
         ExpectToken(tkIdentifier);
+        SaveComments;
         ParseClassLocalTypes(AType,CurVisibility);
         end;
       tkConst:
         begin
         ExpectToken(tkIdentifier);
+        SaveComments;
         ParseClassLocalConsts(AType,CurVisibility);
         end;
       tkVar,
@@ -3853,17 +3950,20 @@ begin
           ParseExc(SParserNoFieldsAllowed);
         if CurToken=tkVar then
           ExpectToken(tkIdentifier);
+        SaveComments;
         if Not CheckVisibility(CurtokenString,CurVisibility) then
           ParseClassFields(AType,CurVisibility,false);
         end;
       tkProcedure,tkFunction,tkConstructor,tkDestructor:
         begin
+        SaveComments;
         if (Curtoken in [tkConstructor,tkDestructor]) and (AType.ObjKind in [okInterface,okRecordHelper]) then
           ParseExc(SParserNoConstructorAllowed);
         ProcessMethod(AType,False,CurVisibility);
         end;
       tkclass:
         begin
+         SaveComments;
          NextToken;
          if CurToken in [tkConstructor,tkDestructor,tkprocedure,tkFunction] then
            ProcessMethod(AType,True,CurVisibility)
@@ -3882,6 +3982,7 @@ begin
         end;
       tkProperty:
         begin
+        SaveComments;
         ExpectIdentifier;
         AType.Members.Add(ParseProperty(AType,CurtokenString,CurVisibility));
         end;
@@ -3948,7 +4049,9 @@ begin
     end;
 end;
 
-function TPasParser.ParseClassDecl(Parent: TPasElement; const AClassName: String; AObjKind: TPasObjKind; PackMode : TPackMode= pmNone): TPasType;
+Function TPasParser.ParseClassDecl(Parent: TPasElement;
+  const AClassName: String; AObjKind: TPasObjKind; PackMode: TPackMode
+  ): TPasType;
 
 Var
   SourcefileName : string;

packages/fcl-passrc/tests/tcbaseparser.pas

@@ -77,6 +77,7 @@ Type
     Procedure HaveHint(AHint : TPasMemberHint; AHints : TPasMemberHints);
     Property Resolver : TStreamResolver Read FResolver;
     Property Scanner : TPascalScanner Read FScanner;
+    Property Engine : TTestEngine read FEngine;
     Property Parser : TTestPasParser read FParser ;
     Property Source : TStrings Read FSource;
     Property Module : TPasModule Read FModule;
@@ -108,6 +109,11 @@ begin
   Result.Visibility := AVisibility;
   Result.SourceFilename := ASourceFilename;
   Result.SourceLinenumber := ASourceLinenumber;
+  if NeedComments and Assigned(CurrentParser) then
+    begin
+//    Writeln('Saving comment : ',CurrentParser.SavedComments);
+    Result.DocComment:=CurrentParser.SavedComments;
+    end;
   If not Assigned(FList) then
     FList:=TFPList.Create;
   FList.Add(Result);

packages/fcl-passrc/tests/tcclasstype.pas

@@ -60,12 +60,14 @@ type
     Property Const2 : TPasConst Index 1 Read GetC;
   published
     procedure TestEmpty;
+    procedure TestEmptyComment;
     procedure TestEmptyDeprecated;
     procedure TestEmptyEnd;
     procedure TestEmptyEndNoParent;
     Procedure TestOneInterface;
     Procedure TestTwoInterfaces;
     Procedure TestOneField;
+    Procedure TestOneFieldComment;
     Procedure TestOneVarField;
     Procedure TestOneClassField;
     Procedure TestOneFieldVisibility;
@@ -83,7 +85,9 @@ type
     procedure TestHintFieldLibraryError;
     procedure TestHintFieldUninmplemented;
     Procedure TestMethodSimple;
+    Procedure TestMethodSimpleComment;
     Procedure TestClassMethodSimple;
+    Procedure TestClassMethodSimpleComment;
     Procedure TestConstructor;
     Procedure TestClassConstructor;
     Procedure TestDestructor;
@@ -108,6 +112,7 @@ type
     Procedure Test2Methods;
     Procedure Test2MethodsDifferentVisibility;
     Procedure TestPropertyRedeclare;
+    Procedure TestPropertyRedeclareComment;
     Procedure TestPropertyRedeclareDefault;
     Procedure TestPropertyReadOnly;
     Procedure TestPropertyReadWrite;
@@ -306,11 +311,17 @@ Procedure TTestClassType.ParseClass;
 begin
   EndClass;
   Add('Type');
+  if AddComment then
+    begin
+    Add('// A comment');
+    engine.NeedComments:=True;
+    end;
   Add('  '+TrimRight(FDecl.Text)+';');
   ParseDeclarations;
   AssertEquals('One class type definition',1,Declarations.Classes.Count);
   AssertEquals('First declaration is type definition.',TPasClassType,TObject(Declarations.Classes[0]).ClassType);
   FClass:=TObject(Declarations.Classes[0]) as TPasClassType;
+  TheType:=FClass; // So assertcomment can get to it
   if (FParent<>'') then
      begin
      AssertNotNull('Have parent class',TheClass.AncestorType);
@@ -323,6 +334,7 @@ begin
     AssertNull('No helperfortype if not helper',TheClass.HelperForType);
   if TheClass.Members.Count>0 then
     FMember1:=TObject(TheClass.Members[0]) as TPaselement;
+
 end;
 
 procedure TTestClassType.SetUp;
@@ -385,6 +397,13 @@ begin
   AssertEquals('No members',0,TheClass.Members.Count);
 end;
 
+procedure TTestClassType.TestEmptyComment;
+begin
+  AddComment:=True;
+  TestEmpty;
+  AssertComment;
+end;
+
 procedure TTestClassType.TestEmptyDeprecated;
 begin
   EndClass('end deprecated');
@@ -438,6 +457,16 @@ begin
   AssertVisibility;
 end;
 
+Procedure TTestClassType.TestOneFieldComment;
+begin
+  AddComment:=true;
+  AddMember('{c}a : integer');
+  ParseClass;
+  AssertNotNull('Have 1 field',Field1);
+  AssertEquals('field comment','c'+sLineBreak,Field1.DocComment);
+  AssertVisibility;
+end;
+
 Procedure TTestClassType.TestOneVarField;
 begin
   StartVisibility(visPublished);
@@ -640,6 +669,18 @@ begin
   AssertEquals('No arguments',0,Method1.ProcType.Args.Count)
 end;
 
+Procedure TTestClassType.TestMethodSimpleComment;
+begin
+  AddComment:=True;
+  AddMember('{c} Procedure DoSomething');
+  ParseClass;
+  AssertEquals('1 members',1,TheClass.members.Count);
+  AssertEquals('Default visibility',visDefault,Method1.Visibility);
+  AssertNotNull('Have method',Method1);
+  AssertMemberName('DoSomething');
+  AssertEquals('Comment','c'+sLineBreak,Method1.DocComment);
+end;
+
 Procedure TTestClassType.TestClassMethodSimple;
 begin
   AddMember('Class Procedure DoSomething');
@@ -654,6 +695,14 @@ begin
   AssertEquals('No arguments',0,TPasClassProcedure(Members[0]).ProcType.Args.Count)
 end;
 
+Procedure TTestClassType.TestClassMethodSimpleComment;
+begin
+  AddComment:=True;
+  AddMember('{c} Class Procedure DoSomething');
+  ParseClass;
+  AssertEquals('Comment','c'+sLineBreak,Members[0].DocComment);
+end;
+
 Procedure TTestClassType.TestConstructor;
 begin
   AddMember('Constructor Create');
@@ -967,6 +1016,16 @@ begin
   Assertequals('No default value','',Property1.DefaultValue);
 end;
 
+Procedure TTestClassType.TestPropertyRedeclareComment;
+begin
+  StartVisibility(visPublished);
+  AddComment:=True;
+  AddMember('{p} Property Something');
+  ParseClass;
+  AssertProperty(Property1,visPublished,'Something','','','','',0,False,False);
+  AssertEquals('comment','p'+sLineBreak,Property1.DocComment);
+end;
+
 Procedure TTestClassType.TestPropertyRedeclareDefault;
 begin
   StartVisibility(visPublic);

packages/fcl-passrc/tests/tcprocfunc.pas

@@ -13,6 +13,7 @@ type
 
   TTestProcedureFunction= class(TTestParser)
   private
+    FAddComment: Boolean;
     FFunc: TPasFunction;
     FHint: String;
     FProc: TPasProcedure;
@@ -35,6 +36,8 @@ type
   protected
     procedure SetUp; override;
     procedure TearDown; override;
+    Procedure AssertComment;
+    Property AddComment : Boolean Read FAddComment Write FAddComment;
     Property Hint : String Read FHint Write FHint;
     Property Proc : TPasProcedure Read FProc;
     Property ProcType : TPasProcedureType Read GetPT;
@@ -42,7 +45,9 @@ type
     Property FuncType : TPasFunctionType Read GetFT;
   published
     procedure TestEmptyProcedure;
+    procedure TestEmptyProcedureComment;
     Procedure TestEmptyFunction;
+    Procedure TestEmptyFunctionComment;
     procedure TestEmptyProcedureDeprecated;
     Procedure TestEmptyFunctionDeprecated;
     procedure TestEmptyProcedurePlatform;
@@ -156,7 +161,8 @@ type
 implementation
 
 
-procedure TTestProcedureFunction.AddDeclaration(Const ASource : string; Const AHint : String = '');
+procedure TTestProcedureFunction.AddDeclaration(const ASource: string;
+  const AHint: String);
 
 Var
   D : String;
@@ -176,16 +182,24 @@ begin
   Result:=Proc.ProcType;
 end;
 
-Function TTestProcedureFunction.ParseProcedure(Const ASource : string; Const AHint : String = '') : TPasProcedure;
+function TTestProcedureFunction.ParseProcedure(const ASource: string;
+  const AHint: String): TPasProcedure;
 
 
 begin
+  If AddComment then
+    begin
+    Add('// A comment');
+    Engine.NeedComments:=True;
+    end;
   AddDeclaration('procedure A '+ASource,AHint);
   Self.ParseProcedure;
   Result:=Fproc;
+  If AddComment then
+    AssertComment;
 end;
 
-procedure TTestProcedureFunction.ParseProcedure;
+Procedure TTestProcedureFunction.ParseProcedure;
 
 begin
   //  Writeln(source.text);
@@ -216,7 +230,7 @@ begin
   AssertEquals('Correct function result type name',AResult,FuncType.ResultEl.ResultType.Name);
 end;
 
-procedure TTestProcedureFunction.ParseFunction;
+Procedure TTestProcedureFunction.ParseFunction;
 begin
   //  Writeln(source.text);
   ParseDeclarations;
@@ -261,7 +275,9 @@ begin
   AssertEquals('Not is nested',False,P.ProcType.IsNested);
 end;
 
-Function TTestProcedureFunction.BaseAssertArg(ProcType : TPasProcedureType; AIndex : Integer; AName : String; AAccess : TArgumentAccess; AValue : String='') : TPasArgument;
+function TTestProcedureFunction.BaseAssertArg(ProcType: TPasProcedureType;
+  AIndex: Integer; AName: String; AAccess: TArgumentAccess; AValue: String
+  ): TPasArgument;
 
 Var
   A : TPasArgument;
@@ -287,7 +303,9 @@ begin
   Result:=A;
 end;
 
-procedure TTestProcedureFunction.AssertArg(ProcType : TPasProcedureType; AIndex : Integer; AName : String; AAccess : TArgumentAccess; Const TypeName : String; AValue : String='');
+procedure TTestProcedureFunction.AssertArg(ProcType: TPasProcedureType;
+  AIndex: Integer; AName: String; AAccess: TArgumentAccess;
+  const TypeName: String; AValue: String);
 
 Var
   A : TPasArgument;
@@ -343,19 +361,31 @@ begin
   AssertProc([],ccDefault,0);
 end;
 
-procedure TTestProcedureFunction.TestEmptyFunction;
+procedure TTestProcedureFunction.TestEmptyProcedureComment;
+begin
+  AddComment:=True;
+  TestEmptyProcedure;
+end;
+
+Procedure TTestProcedureFunction.TestEmptyFunction;
 begin
   ParseFunction('');
   AssertFunc([],ccDefault,0);
 end;
 
+Procedure TTestProcedureFunction.TestEmptyFunctionComment;
+begin
+  AddComment:=True;
+  TestEmptyProcedure;
+end;
+
 procedure TTestProcedureFunction.TestEmptyProcedureDeprecated;
 begin
   ParseProcedure('','deprecated');
   AssertProc([],ccDefault,0);
 end;
 
-procedure TTestProcedureFunction.TestEmptyFunctionDeprecated;
+Procedure TTestProcedureFunction.TestEmptyFunctionDeprecated;
 begin
   ParseFunction('','deprecated');
   AssertFunc([],ccDefault,0);
@@ -367,7 +397,7 @@ begin
   AssertProc([],ccDefault,0);
 end;
 
-procedure TTestProcedureFunction.TestEmptyFunctionPlatform;
+Procedure TTestProcedureFunction.TestEmptyFunctionPlatform;
 begin
   ParseFunction('','platform');
   AssertFunc([],ccDefault,0);
@@ -379,7 +409,7 @@ begin
   AssertProc([],ccDefault,0);
 end;
 
-procedure TTestProcedureFunction.TestEmptyFunctionExperimental;
+Procedure TTestProcedureFunction.TestEmptyFunctionExperimental;
 begin
   ParseFunction('','experimental');
   AssertFunc([],ccDefault,0);
@@ -391,7 +421,7 @@ begin
   AssertProc([],ccDefault,0);
 end;
 
-procedure TTestProcedureFunction.TestEmptyFunctionUnimplemented;
+Procedure TTestProcedureFunction.TestEmptyFunctionUnimplemented;
 begin
   ParseFunction('','unimplemented');
   AssertFunc([],ccDefault,0);
@@ -407,7 +437,7 @@ begin
   AssertArg(ProcType,0,'B',argDefault,'Integer','');
 end;
 
-procedure TTestProcedureFunction.TestFunctionOneArg;
+Procedure TTestProcedureFunction.TestFunctionOneArg;
 begin
   ParseFunction('(B : Integer)');
   AssertFunc([],ccDefault,1);
@@ -421,7 +451,7 @@ begin
   AssertArg(ProcType,0,'B',argVar,'Integer','');
 end;
 
-procedure TTestProcedureFunction.TestFunctionOneVarArg;
+Procedure TTestProcedureFunction.TestFunctionOneVarArg;
 begin
   ParseFunction('(Var B : Integer)');
   AssertFunc([],ccDefault,1);
@@ -435,7 +465,7 @@ begin
   AssertArg(ProcType,0,'B',argConst,'Integer','');
 end;
 
-procedure TTestProcedureFunction.TestFunctionOneConstArg;
+Procedure TTestProcedureFunction.TestFunctionOneConstArg;
 begin
   ParseFunction('(Const B : Integer)');
   AssertFunc([],ccDefault,1);
@@ -449,7 +479,7 @@ begin
   AssertArg(ProcType,0,'B',argOut,'Integer','');
 end;
 
-procedure TTestProcedureFunction.TestFunctionOneOutArg;
+Procedure TTestProcedureFunction.TestFunctionOneOutArg;
 begin
   ParseFunction('(Out B : Integer)');
   AssertFunc([],ccDefault,1);
@@ -463,7 +493,7 @@ begin
   AssertArg(ProcType,0,'B',argConstRef,'Integer','');
 end;
 
-procedure TTestProcedureFunction.TestFunctionOneConstRefArg;
+Procedure TTestProcedureFunction.TestFunctionOneConstRefArg;
 begin
   ParseFunction('(ConstRef B : Integer)');
   AssertFunc([],ccDefault,1);
@@ -478,7 +508,7 @@ begin
   AssertArg(ProcType,1,'C',argDefault,'Integer','');
 end;
 
-procedure TTestProcedureFunction.TestFunctionTwoArgs;
+Procedure TTestProcedureFunction.TestFunctionTwoArgs;
 begin
   ParseFunction('(B,C : Integer)');
   AssertFunc([],ccDefault,2);
@@ -494,7 +524,7 @@ begin
   AssertArg(ProcType,1,'C',argDefault,'Integer','');
 end;
 
-procedure TTestProcedureFunction.TestFunctionTwoArgsSeparate;
+Procedure TTestProcedureFunction.TestFunctionTwoArgsSeparate;
 begin
   ParseFunction('(B : Integer;C : Integer)');
   AssertFunc([],ccDefault,2);
@@ -509,7 +539,7 @@ begin
   AssertArg(ProcType,0,'B',argDefault,'Integer','1');
 end;
 
-procedure TTestProcedureFunction.TestFunctionOneArgDefault;
+Procedure TTestProcedureFunction.TestFunctionOneArgDefault;
 begin
   ParseFunction('(B : Integer = 1)');
   AssertFunc([],ccDefault,1);
@@ -523,7 +553,7 @@ begin
   AssertArg(ProcType,0,'B',argDefault,'MySet','[1, 2]');
 end;
 
-procedure TTestProcedureFunction.TestFunctionOneArgDefaultSet;
+Procedure TTestProcedureFunction.TestFunctionOneArgDefaultSet;
 begin
   ParseFunction('(B : MySet = [1,2])');
   AssertFunc([],ccDefault,1);
@@ -537,7 +567,7 @@ begin
   AssertArg(ProcType,0,'B',argDefault,'Integer','1 + 2');
 end;
 
-procedure TTestProcedureFunction.TestFunctionOneArgDefaultExpr;
+Procedure TTestProcedureFunction.TestFunctionOneArgDefaultExpr;
 begin
   ParseFunction('(B : Integer = 1 + 2)');
   AssertFunc([],ccDefault,1);
@@ -552,7 +582,7 @@ begin
   AssertArg(ProcType,1,'C',argDefault,'Integer','2');
 end;
 
-procedure TTestProcedureFunction.TestFunctionTwoArgsDefault;
+Procedure TTestProcedureFunction.TestFunctionTwoArgsDefault;
 begin
   ParseFunction('(B : Integer = 1; C : Integer = 2)');
   AssertFunc([],ccDefault,2);
@@ -567,7 +597,7 @@ begin
   AssertArg(ProcType,0,'B',argVar,'','');
 end;
 
-procedure TTestProcedureFunction.TestFunctionOneUntypedVarArg;
+Procedure TTestProcedureFunction.TestFunctionOneUntypedVarArg;
 begin
   ParseFunction('(Var B)');
   AssertFunc([],ccDefault,1);
@@ -582,7 +612,7 @@ begin
   AssertArg(ProcType,1,'C',argVar,'','');
 end;
 
-procedure TTestProcedureFunction.TestFunctionTwoUntypedVarArgs;
+Procedure TTestProcedureFunction.TestFunctionTwoUntypedVarArgs;
 begin
   ParseFunction('(Var B; Var C)');
   AssertFunc([],ccDefault,2);
@@ -597,7 +627,7 @@ begin
   AssertArg(ProcType,0,'B',argConst,'','');
 end;
 
-procedure TTestProcedureFunction.TestFunctionOneUntypedConstArg;
+Procedure TTestProcedureFunction.TestFunctionOneUntypedConstArg;
 begin
   ParseFunction('(Const B)');
   AssertFunc([],ccDefault,1);
@@ -612,7 +642,7 @@ begin
   AssertArg(ProcType,1,'C',argConst,'','');
 end;
 
-procedure TTestProcedureFunction.TestFunctionTwoUntypedConstArgs;
+Procedure TTestProcedureFunction.TestFunctionTwoUntypedConstArgs;
 begin
   ParseFunction('(Const B; Const C)');
   AssertFunc([],ccDefault,2);
@@ -627,7 +657,7 @@ begin
   AssertArrayArg(ProcType,0,'B',argDefault,'Integer');
 end;
 
-procedure TTestProcedureFunction.TestFunctionOpenArrayArg;
+Procedure TTestProcedureFunction.TestFunctionOpenArrayArg;
 begin
   ParseFunction('(B : Array of Integer)');
   AssertFunc([],ccDefault,1);
@@ -642,7 +672,7 @@ begin
   AssertArrayArg(ProcType,1,'C',argDefault,'Integer');
 end;
 
-procedure TTestProcedureFunction.TestFunctionTwoOpenArrayArgs;
+Procedure TTestProcedureFunction.TestFunctionTwoOpenArrayArgs;
 begin
   ParseFunction('(B : Array of Integer;C : Array of Integer)');
   AssertFunc([],ccDefault,2);
@@ -657,7 +687,7 @@ begin
   AssertArrayArg(ProcType,0,'B',argConst,'Integer');
 end;
 
-procedure TTestProcedureFunction.TestFunctionConstOpenArrayArg;
+Procedure TTestProcedureFunction.TestFunctionConstOpenArrayArg;
 begin
   ParseFunction('(Const B : Array of Integer)');
   AssertFunc([],ccDefault,1);
@@ -671,7 +701,7 @@ begin
   AssertArrayArg(ProcType,0,'B',argVar,'Integer');
 end;
 
-procedure TTestProcedureFunction.TestFunctionVarOpenArrayArg;
+Procedure TTestProcedureFunction.TestFunctionVarOpenArrayArg;
 begin
   ParseFunction('(Var B : Array of Integer)');
   AssertFunc([],ccDefault,1);
@@ -685,7 +715,7 @@ begin
   AssertArrayArg(ProcType,0,'B',argDefault,'');
 end;
 
-procedure TTestProcedureFunction.TestFunctionArrayOfConstArg;
+Procedure TTestProcedureFunction.TestFunctionArrayOfConstArg;
 begin
   ParseFunction('(B : Array of Const)');
   AssertFunc([],ccDefault,1);
@@ -699,100 +729,100 @@ begin
   AssertArrayArg(ProcType,0,'B',argConst,'');
 end;
 
-procedure TTestProcedureFunction.TestFunctionConstArrayOfConstArg;
+Procedure TTestProcedureFunction.TestFunctionConstArrayOfConstArg;
 begin
   ParseFunction('(Const B : Array of Const)');
   AssertFunc([],ccDefault,1);
   AssertArrayArg(FuncType,0,'B',argConst,'');
 end;
 
-procedure TTestProcedureFunction.TestProcedureCdecl;
+Procedure TTestProcedureFunction.TestProcedureCdecl;
 begin
   ParseProcedure('; cdecl');
   AssertProc([],ccCdecl,0);
 end;
 
-procedure TTestProcedureFunction.TestFunctionCdecl;
+Procedure TTestProcedureFunction.TestFunctionCdecl;
 begin
   ParseFunction('','','',ccCdecl);
   AssertFunc([],ccCdecl,0);
 end;
 
-procedure TTestProcedureFunction.TestProcedureCdeclDeprecated;
+Procedure TTestProcedureFunction.TestProcedureCdeclDeprecated;
 begin
   ParseProcedure('; cdecl;','deprecated');
   AssertProc([],ccCdecl,0);
 end;
 
-procedure TTestProcedureFunction.TestFunctionCdeclDeprecated;
+Procedure TTestProcedureFunction.TestFunctionCdeclDeprecated;
 begin
   ParseFunction('','','deprecated',ccCdecl);
   AssertFunc([],ccCdecl,0);
 end;
 
-procedure TTestProcedureFunction.TestProcedureSafeCall;
+Procedure TTestProcedureFunction.TestProcedureSafeCall;
 begin
   ParseProcedure('; safecall;','');
   AssertProc([],ccSafeCall,0);
 end;
 
-procedure TTestProcedureFunction.TestFunctionSafeCall;
+Procedure TTestProcedureFunction.TestFunctionSafeCall;
 begin
   ParseFunction('','','',ccSafecall);
   AssertFunc([],ccSafecall,0);
 end;
 
-procedure TTestProcedureFunction.TestProcedurePascal;
+Procedure TTestProcedureFunction.TestProcedurePascal;
 begin
   ParseProcedure('; pascal;','');
   AssertProc([],ccPascal,0);
 end;
 
-procedure TTestProcedureFunction.TestFunctionPascal;
+Procedure TTestProcedureFunction.TestFunctionPascal;
 begin
   ParseFunction('','','',ccPascal);
   AssertFunc([],ccPascal,0);
 end;
 
-procedure TTestProcedureFunction.TestProcedureStdCall;
+Procedure TTestProcedureFunction.TestProcedureStdCall;
 begin
   ParseProcedure('; stdcall;','');
   AssertProc([],ccstdcall,0);
 end;
 
-procedure TTestProcedureFunction.TestFunctionStdCall;
+Procedure TTestProcedureFunction.TestFunctionStdCall;
 begin
   ParseFunction('','','',ccStdCall);
   AssertFunc([],ccStdCall,0);
 end;
 
-procedure TTestProcedureFunction.TestProcedureOldFPCCall;
+Procedure TTestProcedureFunction.TestProcedureOldFPCCall;
 begin
   ParseProcedure('; oldfpccall;','');
   AssertProc([],ccoldfpccall,0);
 end;
 
-procedure TTestProcedureFunction.TestFunctionOldFPCCall;
+Procedure TTestProcedureFunction.TestFunctionOldFPCCall;
 begin
   ParseFunction('','','',ccOldFPCCall);
   AssertFunc([],ccOldFPCCall,0);
 end;
 
-procedure TTestProcedureFunction.TestProcedurePublic;
+Procedure TTestProcedureFunction.TestProcedurePublic;
 begin
   ParseProcedure('; public name ''myfunc'';','');
   AssertProc([pmPublic],ccDefault,0);
   AssertExpression('Public name',Proc.PublicName,pekString,'''myfunc''');
 end;
 
-procedure TTestProcedureFunction.TestProcedurePublicIdent;
+Procedure TTestProcedureFunction.TestProcedurePublicIdent;
 begin
   ParseProcedure('; public name exportname;','');
   AssertProc([pmPublic],ccDefault,0);
   AssertExpression('Public name',Proc.PublicName,pekIdent,'exportname');
 end;
 
-procedure TTestProcedureFunction.TestFunctionPublic;
+Procedure TTestProcedureFunction.TestFunctionPublic;
 begin
   AddDeclaration('function A : Integer; public name exportname');
   ParseFunction;
@@ -800,14 +830,14 @@ begin
   AssertExpression('Public name',Func.PublicName,pekIdent,'exportname');
 end;
 
-procedure TTestProcedureFunction.TestProcedureCdeclPublic;
+Procedure TTestProcedureFunction.TestProcedureCdeclPublic;
 begin
   ParseProcedure('; cdecl; public name exportname;','');
   AssertProc([pmPublic],ccCDecl,0);
   AssertExpression('Public name',Proc.PublicName,pekIdent,'exportname');
 end;
 
-procedure TTestProcedureFunction.TestFunctionCdeclPublic;
+Procedure TTestProcedureFunction.TestFunctionCdeclPublic;
 begin
   AddDeclaration('function A : Integer; cdecl; public name exportname');
   ParseFunction;
@@ -815,58 +845,58 @@ begin
   AssertExpression('Public name',Func.PublicName,pekIdent,'exportname');
 end;
 
-procedure TTestProcedureFunction.TestProcedureOverload;
+Procedure TTestProcedureFunction.TestProcedureOverload;
 begin
   ParseProcedure('; overload;','');
   AssertProc([pmOverload],ccDefault,0);
 end;
 
-procedure TTestProcedureFunction.TestFunctionOverload;
+Procedure TTestProcedureFunction.TestFunctionOverload;
 begin
   AddDeclaration('function A : Integer; overload');
   ParseFunction;
   AssertFunc([pmOverload],ccDefault,0);
 end;
 
-procedure TTestProcedureFunction.TestProcedureVarargs;
+Procedure TTestProcedureFunction.TestProcedureVarargs;
 begin
   ParseProcedure('; varargs;','');
   AssertProc([pmVarArgs],ccDefault,0);
 end;
 
-procedure TTestProcedureFunction.TestFunctionVarArgs;
+Procedure TTestProcedureFunction.TestFunctionVarArgs;
 begin
   AddDeclaration('function A : Integer; varargs');
   ParseFunction;
   AssertFunc([pmVarArgs],ccDefault,0);
 end;
 
-procedure TTestProcedureFunction.TestProcedureCDeclVarargs;
+Procedure TTestProcedureFunction.TestProcedureCDeclVarargs;
 begin
   ParseProcedure(';cdecl; varargs;','');
   AssertProc([pmVarArgs],ccCDecl,0);
 end;
 
-procedure TTestProcedureFunction.TestFunctionCDeclVarArgs;
+Procedure TTestProcedureFunction.TestFunctionCDeclVarArgs;
 begin
   AddDeclaration('function A : Integer; cdecl; varargs');
   ParseFunction;
   AssertFunc([pmVarArgs],ccCdecl,0);
 end;
 
-procedure TTestProcedureFunction.TestProcedureForwardInterface;
+Procedure TTestProcedureFunction.TestProcedureForwardInterface;
 begin
   AddDeclaration('procedure A; forward;');
   AssertException(EParserError,@ParseProcedure);
 end;
 
-procedure TTestProcedureFunction.TestFunctionForwardInterface;
+Procedure TTestProcedureFunction.TestFunctionForwardInterface;
 begin
   AddDeclaration('function A : integer; forward;');
   AssertException(EParserError,@ParseFunction);
 end;
 
-procedure TTestProcedureFunction.TestProcedureForward;
+Procedure TTestProcedureFunction.TestProcedureForward;
 begin
   UseImplementation:=True;
   AddDeclaration('procedure A; forward;');
@@ -874,7 +904,7 @@ begin
   AssertProc([pmforward],ccDefault,0);
 end;
 
-procedure TTestProcedureFunction.TestFunctionForward;
+Procedure TTestProcedureFunction.TestFunctionForward;
 begin
   UseImplementation:=True;
   AddDeclaration('function A : integer; forward;');
@@ -882,7 +912,7 @@ begin
   AssertFunc([pmforward],ccDefault,0);
 end;
 
-procedure TTestProcedureFunction.TestProcedureCdeclForward;
+Procedure TTestProcedureFunction.TestProcedureCdeclForward;
 begin
   UseImplementation:=True;
   AddDeclaration('procedure A; cdecl; forward;');
@@ -890,7 +920,7 @@ begin
   AssertProc([pmforward],ccCDecl,0);
 end;
 
-procedure TTestProcedureFunction.TestFunctionCDeclForward;
+Procedure TTestProcedureFunction.TestFunctionCDeclForward;
 begin
   UseImplementation:=True;
   AddDeclaration('function A : integer; cdecl; forward;');
@@ -898,92 +928,92 @@ begin
   AssertFunc([pmforward],ccCDecl,0);
 end;
 
-procedure TTestProcedureFunction.TestProcedureCompilerProc;
+Procedure TTestProcedureFunction.TestProcedureCompilerProc;
 begin
   ParseProcedure(';compilerproc;','');
   AssertProc([pmCompilerProc],ccDefault,0);
 end;
 
-procedure TTestProcedureFunction.TestFunctionCompilerProc;
+Procedure TTestProcedureFunction.TestFunctionCompilerProc;
 begin
   AddDeclaration('function A : Integer; compilerproc');
   ParseFunction;
   AssertFunc([pmCompilerProc],ccDefault,0);
 end;
 
-procedure TTestProcedureFunction.TestProcedureCDeclCompilerProc;
+Procedure TTestProcedureFunction.TestProcedureCDeclCompilerProc;
 begin
   ParseProcedure(';cdecl;compilerproc;','');
   AssertProc([pmCompilerProc],ccCDecl,0);
 end;
 
-procedure TTestProcedureFunction.TestFunctionCDeclCompilerProc;
+Procedure TTestProcedureFunction.TestFunctionCDeclCompilerProc;
 begin
   AddDeclaration('function A : Integer; cdecl; compilerproc');
   ParseFunction;
   AssertFunc([pmCompilerProc],ccCDecl,0);
 end;
 
-procedure TTestProcedureFunction.TestProcedureAssembler;
+Procedure TTestProcedureFunction.TestProcedureAssembler;
 begin
   ParseProcedure(';assembler;','');
   AssertProc([pmAssembler],ccDefault,0);
 end;
 
-procedure TTestProcedureFunction.TestFunctionAssembler;
+Procedure TTestProcedureFunction.TestFunctionAssembler;
 begin
   AddDeclaration('function A : Integer; assembler');
   ParseFunction;
   AssertFunc([pmAssembler],ccDefault,0);
 end;
 
-procedure TTestProcedureFunction.TestProcedureCDeclAssembler;
+Procedure TTestProcedureFunction.TestProcedureCDeclAssembler;
 begin
   ParseProcedure(';cdecl;assembler;','');
   AssertProc([pmAssembler],ccCDecl,0);
 end;
 
-procedure TTestProcedureFunction.TestFunctionCDeclAssembler;
+Procedure TTestProcedureFunction.TestFunctionCDeclAssembler;
 begin
   AddDeclaration('function A : Integer; cdecl; assembler');
   ParseFunction;
   AssertFunc([pmAssembler],ccCDecl,0);
 end;
 
-procedure TTestProcedureFunction.TestProcedureExport;
+Procedure TTestProcedureFunction.TestProcedureExport;
 begin
   ParseProcedure(';export;','');
   AssertProc([pmExport],ccDefault,0);
 end;
 
-procedure TTestProcedureFunction.TestFunctionExport;
+Procedure TTestProcedureFunction.TestFunctionExport;
 begin
   AddDeclaration('function A : Integer; export');
   ParseFunction;
   AssertFunc([pmExport],ccDefault,0);
 end;
 
-procedure TTestProcedureFunction.TestProcedureCDeclExport;
+Procedure TTestProcedureFunction.TestProcedureCDeclExport;
 begin
   ParseProcedure('cdecl;export;','');
   AssertProc([pmExport],ccCDecl,0);
 end;
 
-procedure TTestProcedureFunction.TestFunctionCDeclExport;
+Procedure TTestProcedureFunction.TestFunctionCDeclExport;
 begin
   AddDeclaration('function A : Integer; cdecl; export');
   ParseFunction;
   AssertFunc([pmExport],ccCDecl,0);
 end;
 
-procedure TTestProcedureFunction.TestProcedureExternal;
+Procedure TTestProcedureFunction.TestProcedureExternal;
 begin
   ParseProcedure(';external','');
   AssertProc([pmExternal],ccDefault,0);
   AssertNull('No Library name expression',Proc.LibraryExpr);
 end;
 
-procedure TTestProcedureFunction.TestFunctionExternal;
+Procedure TTestProcedureFunction.TestFunctionExternal;
 begin
   AddDeclaration('function A : Integer; external');
   ParseFunction;
@@ -991,14 +1021,14 @@ begin
   AssertNull('No Library name expression',Func.LibraryExpr);
 end;
 
-procedure TTestProcedureFunction.TestProcedureExternalLibName;
+Procedure TTestProcedureFunction.TestProcedureExternalLibName;
 begin
   ParseProcedure(';external ''libname''','');
   AssertProc([pmExternal],ccDefault,0);
   AssertExpression('Library name expression',Proc.LibraryExpr,pekString,'''libname''');
 end;
 
-procedure TTestProcedureFunction.TestFunctionExternalLibName;
+Procedure TTestProcedureFunction.TestFunctionExternalLibName;
 begin
   AddDeclaration('function A : Integer; external ''libname''');
   ParseFunction;
@@ -1006,7 +1036,7 @@ begin
   AssertExpression('Library name expression',Func.LibraryExpr,pekString,'''libname''');
 end;
 
-procedure TTestProcedureFunction.TestProcedureExternalLibNameName;
+Procedure TTestProcedureFunction.TestProcedureExternalLibNameName;
 begin
   ParseProcedure(';external ''libname'' name ''symbolname''','');
   AssertProc([pmExternal],ccDefault,0);
@@ -1014,7 +1044,7 @@ begin
   AssertExpression('Library symbol expression',Proc.LibrarySymbolName,pekString,'''symbolname''');
 end;
 
-procedure TTestProcedureFunction.TestFunctionExternalLibNameName;
+Procedure TTestProcedureFunction.TestFunctionExternalLibNameName;
 begin
   AddDeclaration('function A : Integer; external ''libname'' name ''symbolname''');
   ParseFunction;
@@ -1023,7 +1053,7 @@ begin
   AssertExpression('Library symbol expression',Func.LibrarySymbolName,pekString,'''symbolname''');
 end;
 
-procedure TTestProcedureFunction.TestProcedureExternalName;
+Procedure TTestProcedureFunction.TestProcedureExternalName;
 begin
   ParseProcedure(';external name ''symbolname''','');
   AssertProc([pmExternal],ccDefault,0);
@@ -1031,7 +1061,7 @@ begin
   AssertExpression('Library symbol expression',Proc.LibrarySymbolName,pekString,'''symbolname''');
 end;
 
-procedure TTestProcedureFunction.TestFunctionExternalName;
+Procedure TTestProcedureFunction.TestFunctionExternalName;
 begin
   AddDeclaration('function A : Integer; external name ''symbolname''');
   ParseFunction;
@@ -1040,14 +1070,14 @@ begin
   AssertExpression('Library symbol expression',Func.LibrarySymbolName,pekString,'''symbolname''');
 end;
 
-procedure TTestProcedureFunction.TestProcedureCdeclExternal;
+Procedure TTestProcedureFunction.TestProcedureCdeclExternal;
 begin
   ParseProcedure('; cdecl; external','');
   AssertProc([pmExternal],ccCdecl,0);
   AssertNull('No Library name expression',Proc.LibraryExpr);
 end;
 
-procedure TTestProcedureFunction.TestFunctionCdeclExternal;
+Procedure TTestProcedureFunction.TestFunctionCdeclExternal;
 begin
   AddDeclaration('function A : Integer; cdecl; external');
   ParseFunction;
@@ -1055,14 +1085,14 @@ begin
   AssertNull('No Library name expression',Func.LibraryExpr);
 end;
 
-procedure TTestProcedureFunction.TestProcedureCdeclExternalLibName;
+Procedure TTestProcedureFunction.TestProcedureCdeclExternalLibName;
 begin
   ParseProcedure('; cdecl; external ''libname''','');
   AssertProc([pmExternal],ccCdecl,0);
   AssertExpression('Library name expression',Proc.LibraryExpr,pekString,'''libname''');
 end;
 
-procedure TTestProcedureFunction.TestFunctionCdeclExternalLibName;
+Procedure TTestProcedureFunction.TestFunctionCdeclExternalLibName;
 begin
   AddDeclaration('function A : Integer; cdecl; external ''libname''');
   ParseFunction;
@@ -1070,7 +1100,7 @@ begin
   AssertExpression('Library name expression',Func.LibraryExpr,pekString,'''libname''');
 end;
 
-procedure TTestProcedureFunction.TestProcedureCdeclExternalLibNameName;
+Procedure TTestProcedureFunction.TestProcedureCdeclExternalLibNameName;
 begin
   ParseProcedure('; cdecl; external ''libname'' name ''symbolname''','');
   AssertProc([pmExternal],ccCdecl,0);
@@ -1078,7 +1108,7 @@ begin
   AssertExpression('Library symbol expression',Proc.LibrarySymbolName,pekString,'''symbolname''');
 end;
 
-procedure TTestProcedureFunction.TestFunctionCdeclExternalLibNameName;
+Procedure TTestProcedureFunction.TestFunctionCdeclExternalLibNameName;
 begin
   AddDeclaration('function A : Integer; cdecl; external ''libname'' name ''symbolname''');
   ParseFunction;
@@ -1087,7 +1117,7 @@ begin
   AssertExpression('Library symbol expression',Func.LibrarySymbolName,pekString,'''symbolname''');
 end;
 
-procedure TTestProcedureFunction.TestProcedureCdeclExternalName;
+Procedure TTestProcedureFunction.TestProcedureCdeclExternalName;
 begin
   ParseProcedure('; cdecl; external name ''symbolname''','');
   AssertProc([pmExternal],ccCdecl,0);
@@ -1095,7 +1125,7 @@ begin
   AssertExpression('Library symbol expression',Proc.LibrarySymbolName,pekString,'''symbolname''');
 end;
 
-procedure TTestProcedureFunction.TestFunctionCdeclExternalName;
+Procedure TTestProcedureFunction.TestFunctionCdeclExternalName;
 begin
   AddDeclaration('function A : Integer; cdecl; external name ''symbolname''');
   ParseFunction;
@@ -1114,6 +1144,11 @@ begin
    Inherited;
 end;
 
+Procedure TTestProcedureFunction.AssertComment;
+begin
+  AssertEquals('Correct comment',' A comment'+sLineBreak,FProc.DocComment);
+end;
+
 initialization
 
   RegisterTest(TTestProcedureFunction);

packages/fcl-passrc/tests/tcstatements.pas

@@ -31,12 +31,15 @@ Type
     Procedure TestEmptyStatement;
     Procedure TestEmptyStatements;
     Procedure TestBlock;
+    Procedure TestBlockComment;
+    Procedure TestBlock2Comments;
     Procedure TestAssignment;
     Procedure TestAssignmentAdd;
     Procedure TestAssignmentMinus;
     Procedure TestAssignmentMul;
     Procedure TestAssignmentDivision;
     Procedure TestCall;
+    Procedure TestCallComment;
     Procedure TestCallQualified;
     Procedure TestCallQualified2;
     Procedure TestCallNoArgs;
@@ -95,19 +98,19 @@ implementation
 
 { TTestStatementParser }
 
-procedure TTestStatementParser.SetUp;
+Procedure TTestStatementParser.SetUp;
 begin
   inherited SetUp;
   FVariables:=TStringList.Create;
 end;
 
-procedure TTestStatementParser.TearDown;
+Procedure TTestStatementParser.TearDown;
 begin
   FreeAndNil(FVariables);
   inherited TearDown;
 end;
 
-procedure TTestStatementParser.AddStatements(ASource: array of string);
+procedure TTestStatementParser.AddStatements(ASource: Array of string);
 
 Var
   I :Integer;
@@ -124,8 +127,8 @@ begin
     Add('  '+ASource[i]);
 end;
 
-procedure TTestStatementParser.DeclareVar(const AVarType: String;
-  const AVarName: String);
+Procedure TTestStatementParser.DeclareVar(Const AVarType: String;
+  Const AVarName: String);
 begin
   FVariables.Add(AVarName+' : '+AVarType+';');
 end;
@@ -135,7 +138,8 @@ begin
   Result:=TestStatement([ASource]);
 end;
 
-function TTestStatementParser.TestStatement(ASource: array of string): TPasImplElement;
+function TTestStatementParser.TestStatement(ASource: Array of string
+  ): TPasImplElement;
 
 
 begin
@@ -152,19 +156,19 @@ begin
   Result:=FStatement;
 end;
 
-procedure TTestStatementParser.ExpectParserError(Const Msg : string);
+Procedure TTestStatementParser.ExpectParserError(Const Msg: string);
 begin
   AssertException(Msg,EParserError,@ParseModule);
 end;
 
-procedure TTestStatementParser.ExpectParserError(const Msg: string;
-  ASource: array of string);
+Procedure TTestStatementParser.ExpectParserError(Const Msg: string;
+  ASource: Array of string);
 begin
   AddStatements(ASource);
   ExpectParserError(Msg);
 end;
 
-function TTestStatementParser.AssertStatement(Msg: String; AClass: TClass;
+Function TTestStatementParser.AssertStatement(Msg: String; AClass: TClass;
   AIndex: Integer): TPasImplBlock;
 begin
   if not (AIndex<PasProgram.InitializationSection.Elements.Count) then
@@ -174,26 +178,26 @@ begin
   Result:=TObject(PasProgram.InitializationSection.Elements[AIndex]) as TPasImplBlock;
 end;
 
-procedure TTestStatementParser.TestEmpty;
+Procedure TTestStatementParser.TestEmpty;
 begin
   //TestStatement(';');
   TestStatement('');
   AssertEquals('No statements',0,PasProgram.InitializationSection.Elements.Count);
 end;
 
-procedure TTestStatementParser.TestEmptyStatement;
+Procedure TTestStatementParser.TestEmptyStatement;
 begin
   TestStatement(';');
   AssertEquals('0 statement',0,PasProgram.InitializationSection.Elements.Count);
 end;
 
-procedure TTestStatementParser.TestEmptyStatements;
+Procedure TTestStatementParser.TestEmptyStatements;
 begin
   TestStatement(';;');
   AssertEquals('0 statement',0,PasProgram.InitializationSection.Elements.Count);
 end;
 
-procedure TTestStatementParser.TestBlock;
+Procedure TTestStatementParser.TestBlock;
 
 Var
   B : TPasImplBeginBlock;
@@ -207,7 +211,37 @@ begin
   AssertEquals('Empty block',0,B.Elements.Count);
 end;
 
-procedure TTestStatementParser.TestAssignment;
+Procedure TTestStatementParser.TestBlockComment;
+Var
+  B : TPasImplBeginBlock;
+
+begin
+  Engine.NeedComments:=True;
+  TestStatement(['{ This is a comment }','begin','end']);
+  AssertEquals('1 statement',1,PasProgram.InitializationSection.Elements.Count);
+  AssertNotNull('Statement assigned',PasProgram.InitializationSection.Elements[0]);
+  AssertEquals('Block statement',TPasImplBeginBlock,Statement.ClassType);
+  B:= Statement as TPasImplBeginBlock;
+  AssertEquals('Empty block',0,B.Elements.Count);
+  AssertEquals('No DocComment','',B.DocComment);
+end;
+
+Procedure TTestStatementParser.TestBlock2Comments;
+Var
+  B : TPasImplBeginBlock;
+
+begin
+  Engine.NeedComments:=True;
+  TestStatement(['{ This is a comment }','// Another comment','begin','end']);
+  AssertEquals('1 statement',1,PasProgram.InitializationSection.Elements.Count);
+  AssertNotNull('Statement assigned',PasProgram.InitializationSection.Elements[0]);
+  AssertEquals('Block statement',TPasImplBeginBlock,Statement.ClassType);
+  B:= Statement as TPasImplBeginBlock;
+  AssertEquals('Empty block',0,B.Elements.Count);
+  AssertEquals('No DocComment','',B.DocComment);
+end;
+
+Procedure TTestStatementParser.TestAssignment;
 
 Var
   A : TPasImplAssign;
@@ -223,7 +257,7 @@ begin
   AssertExpression('Left side is variable',A.Left,pekIdent,'a');
 end;
 
-procedure TTestStatementParser.TestAssignmentAdd;
+Procedure TTestStatementParser.TestAssignmentAdd;
 
 Var
   A : TPasImplAssign;
@@ -240,7 +274,7 @@ begin
   AssertExpression('Left side is variable',A.Left,pekIdent,'a');
 end;
 
-procedure TTestStatementParser.TestAssignmentMinus;
+Procedure TTestStatementParser.TestAssignmentMinus;
 Var
   A : TPasImplAssign;
 
@@ -256,7 +290,7 @@ begin
   AssertExpression('Left side is variable',A.Left,pekIdent,'a');
 end;
 
-procedure TTestStatementParser.TestAssignmentMul;
+Procedure TTestStatementParser.TestAssignmentMul;
 Var
   A : TPasImplAssign;
 
@@ -272,7 +306,7 @@ begin
   AssertExpression('Left side is variable',A.Left,pekIdent,'a');
 end;
 
-procedure TTestStatementParser.TestAssignmentDivision;
+Procedure TTestStatementParser.TestAssignmentDivision;
 Var
   A : TPasImplAssign;
 
@@ -288,7 +322,7 @@ begin
   AssertExpression('Left side is variable',A.Left,pekIdent,'a');
 end;
 
-procedure TTestStatementParser.TestCall;
+Procedure TTestStatementParser.TestCall;
 
 Var
   S : TPasImplSimple;
@@ -301,7 +335,22 @@ begin
   AssertExpression('Doit call',S.Expr,pekIdent,'Doit');
 end;
 
-procedure TTestStatementParser.TestCallQualified;
+Procedure TTestStatementParser.TestCallComment;
+
+Var
+  S : TPasImplSimple;
+begin
+  Engine.NeedComments:=True;
+  TestStatement(['//comment line','Doit;']);
+  AssertEquals('1 statement',1,PasProgram.InitializationSection.Elements.Count);
+  AssertEquals('Simple statement',TPasImplSimple,Statement.ClassType);
+  AssertEquals('1 statement',1,PasProgram.InitializationSection.Elements.Count);
+  S:=Statement as TPasImplSimple;
+  AssertExpression('Doit call',S.Expr,pekIdent,'Doit');
+  AssertEquals('No DocComment','',S.DocComment);
+end;
+
+Procedure TTestStatementParser.TestCallQualified;
 
 Var
   S : TPasImplSimple;
@@ -319,7 +368,7 @@ begin
 
 end;
 
-procedure TTestStatementParser.TestCallQualified2;
+Procedure TTestStatementParser.TestCallQualified2;
 Var
   S : TPasImplSimple;
   B : TBinaryExpr;
@@ -338,7 +387,7 @@ begin
   AssertExpression('Doit call',B.Right,pekIdent,'Doit');
 end;
 
-procedure TTestStatementParser.TestCallNoArgs;
+Procedure TTestStatementParser.TestCallNoArgs;
 
 Var
   S : TPasImplSimple;
@@ -355,7 +404,7 @@ begin
   AssertEquals('No params',0,Length(P.Params));
 end;
 
-procedure TTestStatementParser.TestCallOneArg;
+Procedure TTestStatementParser.TestCallOneArg;
 Var
   S : TPasImplSimple;
   P : TParamsExpr;
@@ -372,7 +421,7 @@ begin
   AssertExpression('Parameter is constant',P.Params[0],pekNumber,'1');
 end;
 
-procedure TTestStatementParser.TestIf;
+Procedure TTestStatementParser.TestIf;
 
 Var
   I : TPasImplIfElse;
@@ -386,7 +435,7 @@ begin
   AssertNull('No if branch',I.IfBranch);
 end;
 
-procedure TTestStatementParser.TestIfBlock;
+Procedure TTestStatementParser.TestIfBlock;
 
 Var
   I : TPasImplIfElse;
@@ -401,7 +450,7 @@ begin
   AssertEquals('begin end block',TPasImplBeginBlock,I.ifBranch.ClassType);
 end;
 
-procedure TTestStatementParser.TestIfAssignment;
+Procedure TTestStatementParser.TestIfAssignment;
 
 Var
   I : TPasImplIfElse;
@@ -416,7 +465,7 @@ begin
   AssertEquals('assignment statement',TPasImplAssign,I.ifBranch.ClassType);
 end;
 
-procedure TTestStatementParser.TestIfElse;
+Procedure TTestStatementParser.TestIfElse;
 
 Var
   I : TPasImplIfElse;
@@ -431,7 +480,7 @@ begin
   AssertEquals('begin end block',TPasImplBeginBlock,I.ifBranch.ClassType);
 end;
 
-procedure TTestStatementParser.TestIfElseBlock;
+Procedure TTestStatementParser.TestIfElseBlock;
 Var
   I : TPasImplIfElse;
 
@@ -446,14 +495,14 @@ begin
   AssertEquals('begin end block',TPasImplBeginBlock,I.ElseBranch.ClassType);
 end;
 
-procedure TTestStatementParser.TestIfSemiColonElseError;
+Procedure TTestStatementParser.TestIfSemiColonElseError;
 
 begin
   DeclareVar('boolean');
   ExpectParserError('No semicolon before else',['if a then','  begin','  end;','else','  begin','  end']);
 end;
 
-procedure TTestStatementParser.TestNestedIf;
+Procedure TTestStatementParser.TestNestedIf;
 Var
   I : TPasImplIfElse;
 begin
@@ -470,7 +519,7 @@ begin
 
 end;
 
-procedure TTestStatementParser.TestNestedIfElse;
+Procedure TTestStatementParser.TestNestedIfElse;
 
 Var
   I : TPasImplIfElse;
@@ -488,7 +537,7 @@ begin
   AssertEquals('begin end block',TPasImplBeginBlock,I.ElseBranch.ClassType);
 end;
 
-procedure TTestStatementParser.TestWhile;
+Procedure TTestStatementParser.TestWhile;
 
 Var
   W : TPasImplWhileDo;
@@ -501,7 +550,7 @@ begin
   AssertNull('Empty body',W.Body);
 end;
 
-procedure TTestStatementParser.TestWhileBlock;
+Procedure TTestStatementParser.TestWhileBlock;
 Var
   W : TPasImplWhileDo;
 
@@ -515,7 +564,7 @@ begin
   AssertEquals('Empty block',0,TPasImplBeginBlock(W.Body).ELements.Count);
 end;
 
-procedure TTestStatementParser.TestWhileNested;
+Procedure TTestStatementParser.TestWhileNested;
 
 Var
   W : TPasImplWhileDo;
@@ -535,7 +584,7 @@ begin
   AssertEquals('Empty nested block',0,TPasImplBeginBlock(W.Body).ELements.Count);
 end;
 
-procedure TTestStatementParser.TestRepeat;
+Procedure TTestStatementParser.TestRepeat;
 
 Var
   R : TPasImplRepeatUntil;
@@ -548,7 +597,7 @@ begin
   AssertEquals('Empty body',0,R.Elements.Count);
 end;
 
-procedure TTestStatementParser.TestRepeatBlock;
+Procedure TTestStatementParser.TestRepeatBlock;
 
 Var
   R : TPasImplRepeatUntil;
@@ -578,7 +627,7 @@ begin
   AssertEquals('Empty block',0,TPasImplBeginBlock(R.Elements[0]).ELements.Count);
 end;
 
-procedure TTestStatementParser.TestRepeatNested;
+Procedure TTestStatementParser.TestRepeatNested;
 
 Var
   R : TPasImplRepeatUntil;
@@ -598,7 +647,7 @@ begin
   AssertEquals('Empty block',0,TPasImplBeginBlock(R.Elements[0]).ELements.Count);
 end;
 
-procedure TTestStatementParser.TestFor;
+Procedure TTestStatementParser.TestFor;
 
 Var
   F : TPasImplForLoop;
@@ -615,7 +664,7 @@ begin
   AssertNull('Empty body',F.Body);
 end;
 
-procedure TTestStatementParser.TestForIn;
+Procedure TTestStatementParser.TestForIn;
 
 Var
   F : TPasImplForLoop;
@@ -632,7 +681,7 @@ begin
   AssertNull('Empty body',F.Body);
 end;
 
-procedure TTestStatementParser.TestForExpr;
+Procedure TTestStatementParser.TestForExpr;
 Var
   F : TPasImplForLoop;
   B : TBinaryExpr;
@@ -654,7 +703,7 @@ begin
   AssertNull('Empty body',F.Body);
 end;
 
-procedure TTestStatementParser.TestForBlock;
+Procedure TTestStatementParser.TestForBlock;
 
 Var
   F : TPasImplForLoop;
@@ -690,7 +739,7 @@ begin
   AssertEquals('Empty block',0,TPasImplBeginBlock(F.Body).ELements.Count);
 end;
 
-procedure TTestStatementParser.TestForNested;
+Procedure TTestStatementParser.TestForNested;
 Var
   F : TPasImplForLoop;
 
@@ -715,7 +764,7 @@ begin
   AssertEquals('Empty block',0,TPasImplBeginBlock(F.Body).ELements.Count);
 end;
 
-procedure TTestStatementParser.TestWith;
+Procedure TTestStatementParser.TestWith;
 
 Var
   W : TpasImplWithDo;
@@ -731,7 +780,7 @@ begin
   AssertEquals('Empty block',0,TPasImplBeginBlock(W.Body).ELements.Count);
 end;
 
-procedure TTestStatementParser.TestWithMultiple;
+Procedure TTestStatementParser.TestWithMultiple;
 Var
   W : TpasImplWithDo;
 
@@ -748,14 +797,14 @@ begin
   AssertEquals('Empty block',0,TPasImplBeginBlock(W.Body).ELements.Count);
 end;
 
-procedure TTestStatementParser.TestCaseEmpty;
+Procedure TTestStatementParser.TestCaseEmpty;
 begin
   DeclareVar('integer');
   AddStatements(['case a of','end;']);
   ExpectParserError('Empty case not allowed');
 end;
 
-procedure TTestStatementParser.TestCaseOneInteger;
+Procedure TTestStatementParser.TestCaseOneInteger;
 
 Var
   C : TPasImplCaseOf;
@@ -777,7 +826,7 @@ begin
   AssertNull('Empty case label statement',S.Body);
 end;
 
-procedure TTestStatementParser.TestCaseTwoIntegers;
+Procedure TTestStatementParser.TestCaseTwoIntegers;
 
 Var
   C : TPasImplCaseOf;
@@ -800,7 +849,7 @@ begin
   AssertNull('Empty case label statement',S.Body);
 end;
 
-procedure TTestStatementParser.TestCaseRange;
+Procedure TTestStatementParser.TestCaseRange;
 Var
   C : TPasImplCaseOf;
   S : TPasImplCaseStatement;
@@ -821,7 +870,7 @@ begin
   AssertNull('Empty case label statement',S.Body);
 end;
 
-procedure TTestStatementParser.TestCaseRangeSeparate;
+Procedure TTestStatementParser.TestCaseRangeSeparate;
 Var
   C : TPasImplCaseOf;
   S : TPasImplCaseStatement;
@@ -843,7 +892,7 @@ begin
   AssertNull('Empty case label statement',S.Body);
 end;
 
-procedure TTestStatementParser.TestCase2Cases;
+Procedure TTestStatementParser.TestCase2Cases;
 Var
   C : TPasImplCaseOf;
   S : TPasImplCaseStatement;
@@ -871,7 +920,7 @@ begin
   AssertNull('Empty case label statement 2',S.Body);
 end;
 
-procedure TTestStatementParser.TestCaseBlock;
+Procedure TTestStatementParser.TestCaseBlock;
 
 Var
   C : TPasImplCaseOf;
@@ -897,7 +946,7 @@ begin
 
 end;
 
-procedure TTestStatementParser.TestCaseElseBlockEmpty;
+Procedure TTestStatementParser.TestCaseElseBlockEmpty;
 
 Var
   C : TPasImplCaseOf;
@@ -924,7 +973,7 @@ begin
   AssertEquals('Zero statements ',0,TPasImplCaseElse(C.ElseBranch).Elements.Count);
 end;
 
-procedure TTestStatementParser.TestCaseElseBlockAssignment;
+Procedure TTestStatementParser.TestCaseElseBlockAssignment;
 Var
   C : TPasImplCaseOf;
   S : TPasImplCaseStatement;
@@ -950,7 +999,7 @@ begin
   AssertEquals('1 statement in else branch ',1,TPasImplCaseElse(C.ElseBranch).Elements.Count);
 end;
 
-procedure TTestStatementParser.TestCaseElseBlock2Assignments;
+Procedure TTestStatementParser.TestCaseElseBlock2Assignments;
 
 Var
   C : TPasImplCaseOf;
@@ -977,7 +1026,7 @@ begin
   AssertEquals('2 statements in else branch ',2,TPasImplCaseElse(C.ElseBranch).Elements.Count);
 end;
 
-procedure TTestStatementParser.TestCaseIfCaseElse;
+Procedure TTestStatementParser.TestCaseIfCaseElse;
 
 Var
   C : TPasImplCaseOf;
@@ -995,7 +1044,7 @@ begin
   AssertEquals('0 statement in else branch ',0,TPasImplCaseElse(C.ElseBranch).Elements.Count);
 end;
 
-procedure TTestStatementParser.TestCaseIfElse;
+Procedure TTestStatementParser.TestCaseIfElse;
 Var
   C : TPasImplCaseOf;
   S : TPasImplCaseStatement;
@@ -1017,7 +1066,7 @@ begin
   AssertNotNull('If statement has else block',TPasImplIfElse(S.Elements[0]).ElseBranch);
 end;
 
-procedure TTestStatementParser.TestRaise;
+Procedure TTestStatementParser.TestRaise;
 
 Var
   R : TPasImplRaise;
@@ -1032,7 +1081,7 @@ begin
   AssertExpression('Expression object',R.ExceptObject,pekIdent,'A');
 end;
 
-procedure TTestStatementParser.TestRaiseEmpty;
+Procedure TTestStatementParser.TestRaiseEmpty;
 Var
   R : TPasImplRaise;
 
@@ -1044,7 +1093,7 @@ begin
   AssertNull(R.ExceptAddr);
 end;
 
-procedure TTestStatementParser.TestRaiseAt;
+Procedure TTestStatementParser.TestRaiseAt;
 
 Var
   R : TPasImplRaise;
@@ -1060,7 +1109,7 @@ begin
   AssertExpression('Expression object',R.ExceptAddr,pekIdent,'B');
 end;
 
-procedure TTestStatementParser.TestTryFinally;
+Procedure TTestStatementParser.TestTryFinally;
 
 Var
   T : TPasImplTry;
@@ -1086,7 +1135,7 @@ begin
   AssertExpression('DoSomethingElse call',S.Expr,pekIdent,'DoSomethingElse');
 end;
 
-procedure TTestStatementParser.TestTryFinallyEmpty;
+Procedure TTestStatementParser.TestTryFinallyEmpty;
 Var
   T : TPasImplTry;
   F : TPasImplTryFinally;
@@ -1102,7 +1151,7 @@ begin
   AssertEquals(0,F.Elements.Count);
 end;
 
-procedure TTestStatementParser.TestTryFinallyNested;
+Procedure TTestStatementParser.TestTryFinallyNested;
 Var
   T : TPasImplTry;
   S : TPasImplSimple;
@@ -1230,7 +1279,7 @@ begin
   AssertEquals(0,E.Elements.Count);
 end;
 
-procedure TTestStatementParser.TestTryExceptOn;
+Procedure TTestStatementParser.TestTryExceptOn;
 
 Var
   T : TPasImplTry;
@@ -1264,7 +1313,7 @@ begin
 
 end;
 
-procedure TTestStatementParser.TestTryExceptOn2;
+Procedure TTestStatementParser.TestTryExceptOn2;
 
 Var
   T : TPasImplTry;
@@ -1309,7 +1358,7 @@ begin
   AssertExpression('DoSomethingElse call',S.Expr,pekIdent,'DoSomethingElse2');
 end;
 
-procedure TTestStatementParser.TestTryExceptOnElse;
+Procedure TTestStatementParser.TestTryExceptOnElse;
 Var
   T : TPasImplTry;
   S : TPasImplSimple;
@@ -1356,7 +1405,7 @@ begin
   AssertExpression('DoSomething call',S.Expr,pekIdent,'DoSomethingMore');
 end;
 
-procedure TTestStatementParser.TestTryExceptOnIfElse;
+Procedure TTestStatementParser.TestTryExceptOnIfElse;
 Var
   T : TPasImplTry;
   S : TPasImplSimple;

packages/fcl-passrc/tests/testpassrc.lpi

@@ -30,7 +30,7 @@
     <RunParams>
       <local>
         <FormatVersion Value="1"/>
-        <CommandLineParams Value="--suite=TTestRecordTypeParser.TestVisibilityAndMethods"/>
+        <CommandLineParams Value="--suite=TTestStatementParser.TestCallComment"/>
       </local>
     </RunParams>
     <RequiredPackages Count="1">
@@ -42,7 +42,6 @@
       <Unit0>
         <Filename Value="testpassrc.lpr"/>
         <IsPartOfProject Value="True"/>
-        <UnitName Value="testpassrc"/>
       </Unit0>
       <Unit1>
         <Filename Value="tcscanner.pas"/>
@@ -67,17 +66,14 @@
       <Unit5>
         <Filename Value="tcmoduleparser.pas"/>
         <IsPartOfProject Value="True"/>
-        <UnitName Value="tcmoduleparser"/>
       </Unit5>
       <Unit6>
         <Filename Value="tconstparser.pas"/>
         <IsPartOfProject Value="True"/>
-        <UnitName Value="tconstparser"/>
       </Unit6>
       <Unit7>
         <Filename Value="tcvarparser.pas"/>
         <IsPartOfProject Value="True"/>
-        <UnitName Value="tcvarparser"/>
       </Unit7>
       <Unit8>
         <Filename Value="tcclasstype.pas"/>
@@ -107,12 +103,6 @@
       <IncludeFiles Value="$(ProjOutDir)"/>
       <OtherUnitFiles Value="../src"/>
     </SearchPaths>
-    <Other>
-      <CompilerMessages>
-        <UseMsgFile Value="True"/>
-      </CompilerMessages>
-      <CompilerPath Value="$(CompPath)"/>
-    </Other>
   </CompilerOptions>
   <Debugging>
     <Exceptions Count="3">