diff --git a/packages/fcl-passrc/src/pastree.pp b/packages/fcl-passrc/src/pastree.pp
index 81a0ce7962..199e1047cb 100644
--- a/packages/fcl-passrc/src/pastree.pp
+++ b/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
diff --git a/packages/fcl-passrc/src/pparser.pp b/packages/fcl-passrc/src/pparser.pp
index bf861e95c7..d801bc2748 100644
--- a/packages/fcl-passrc/src/pparser.pp
+++ b/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;
diff --git a/packages/fcl-passrc/tests/tcbaseparser.pas b/packages/fcl-passrc/tests/tcbaseparser.pas
index 16f10a954a..75f095e209 100644
--- a/packages/fcl-passrc/tests/tcbaseparser.pas
+++ b/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);
diff --git a/packages/fcl-passrc/tests/tcclasstype.pas b/packages/fcl-passrc/tests/tcclasstype.pas
index 292f3852dd..e1df996aa8 100644
--- a/packages/fcl-passrc/tests/tcclasstype.pas
+++ b/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);
diff --git a/packages/fcl-passrc/tests/tcprocfunc.pas b/packages/fcl-passrc/tests/tcprocfunc.pas
index bc36f2103c..ba64abe9d4 100644
--- a/packages/fcl-passrc/tests/tcprocfunc.pas
+++ b/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);
diff --git a/packages/fcl-passrc/tests/tcstatements.pas b/packages/fcl-passrc/tests/tcstatements.pas
index 74a96ac07e..1e1e7cda60 100644
--- a/packages/fcl-passrc/tests/tcstatements.pas
+++ b/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;
diff --git a/packages/fcl-passrc/tests/tctypeparser.pas b/packages/fcl-passrc/tests/tctypeparser.pas
index 6e6349d5c0..fdcaca6b12 100644
--- a/packages/fcl-passrc/tests/tctypeparser.pas
+++ b/packages/fcl-passrc/tests/tctypeparser.pas
@@ -13,16 +13,19 @@ type
 
   TBaseTestTypeParser= Class(TTestParser)
   private
+    FAddComment: Boolean;
     FType : TPasType;
     FHint : string;
     FErrorSource : String;
   Protected
     Function ParseType(ASource : String; ATypeClass : TClass;Const AHint : String = '') : TPasType; virtual; overload;
     Procedure AssertParseTypeError(ASource : String);
-    Property TheType : TPasType Read FType;
-    Property Hint : string Read FHint Write FHint;
+    Procedure AssertComment;
     procedure SetUp; override;
     Procedure TearDown; override;
+    Property TheType : TPasType Read FType Write FType;
+    Property Hint : string Read FHint Write FHint;
+    Property AddComment : Boolean Read FAddComment Write FAddComment;
   end;
 
   { TTestTypeParser }
@@ -50,6 +53,7 @@ type
     Procedure TestAliasTypeDeprecated;
     Procedure TestAliasTypePlatform;
     Procedure TestSimpleTypeByte;
+    Procedure TestSimpleTypeByteComment;
     Procedure TestSimpleTypeByteDeprecated;
     Procedure TestSimpleTypeBytePlatform;
     Procedure TestSimpleTypeBoolean;
@@ -103,12 +107,16 @@ type
     procedure TestPointerSimpleDeprecated;
     procedure TestPointerSimplePlatform;
     Procedure TestStaticArray;
+    Procedure TestStaticArrayComment;
     procedure TestStaticArrayDeprecated;
     procedure TestStaticArrayPlatform;
     Procedure TestStaticArrayPacked;
     Procedure TestStaticArrayTypedIndex;
     Procedure TestDynamicArray;
+    Procedure TestDynamicArrayComment;
     Procedure TestSimpleEnumerated;
+    Procedure TestSimpleEnumeratedComment;
+    Procedure TestSimpleEnumeratedComment2;
     Procedure TestSimpleEnumeratedDeprecated;
     Procedure TestSimpleEnumeratedPlatform;
     Procedure TestAssignedEnumerated;
@@ -135,6 +143,7 @@ type
     Procedure TestRangeSetDeprecated;
     Procedure TestRangeSetPlatform;
     Procedure TestClassOf;
+    Procedure TestClassOfComment;
     Procedure TestClassOfDeprecated;
     Procedure TestClassOfPlatform;
     Procedure TestReferenceAlias;
@@ -161,7 +170,6 @@ type
     procedure AssertField1(Hints: TPasMemberHints);
     procedure AssertField2(Hints: TPasMemberHints);
     procedure AssertMethod2(Hints: TPasMemberHints);
-    procedure AssertProperty2(Hints: TPasMemberHints);
     procedure AssertVariant1(Hints: TPasMemberHints);
     procedure AssertVariant1(Hints: TPasMemberHints; VariantLabels : Array of string);
     procedure AssertVariant2(Hints: TPasMemberHints);
@@ -195,9 +203,11 @@ type
     Property Variant2 : TPasVariant Index 1 Read GetV;
   Published
     Procedure TestEmpty;
+    Procedure TestEmptyComment;
     Procedure TestEmptyDeprecated;
     Procedure TestEmptyPlatform;
     Procedure TestOneField;
+    Procedure TestOneFieldComment;
     Procedure TestOneFieldDeprecated;
     Procedure TestOneFieldPlatform;
     Procedure TestOneFieldSemicolon;
@@ -233,8 +243,6 @@ type
     Procedure TestTwoDeprecatedFieldsCombinedPlatform;
     Procedure TestFieldAndMethod;
     Procedure TestFieldAnd2Methods;
-    Procedure TestFieldAndProperty;
-    Procedure TestVisibilityAndMethods;
     Procedure TestNested;
     Procedure TestNestedDeprecated;
     Procedure TestNestedPlatform;
@@ -351,6 +359,7 @@ type
     Property Proc : TPasProcedureType Read FProc;
   Published
     Procedure TestProcedure;
+    Procedure TestProcedureComment;
     Procedure TestProcedureOneArg;
     Procedure TestProcedureOneVarArg;
     Procedure TestProcedureOneConstArg;
@@ -694,8 +703,8 @@ begin
   AssertEquals('No params',0,Length(B.Params));
 end;
 
-Function TTestProcedureTypeParser.CheckArgument(AIndex: Integer; const AName,
-  ATypeName: String; AAccess: TArgumentAccess) : TPAsArgument;
+function TTestProcedureTypeParser.CheckArgument(AIndex: Integer; Const AName,
+  ATypeName: String; AAccess: TArgumentAccess): TPasArgument;
 Var
   A : TPasArgument;
   C : String;
@@ -717,8 +726,9 @@ begin
   Result:=A;
 end;
 
-function TTestProcedureTypeParser.ParseType(ASource: String;
-  CC: TCallingConvention; ATypeClass: TClass; const AHint: String): TPasProcedureType;
+Function TTestProcedureTypeParser.ParseType(ASource: String;
+  CC: TCallingConvention; ATypeClass: TClass; Const AHint: String
+  ): TPasProcedureType;
 begin
   if CC=ccdefault then
     Result:=TPasProcedureType(ParseType(ASource,ATypeClass,AHint))
@@ -733,15 +743,18 @@ begin
   AssertEquals('Correct calling convention for procedural type',cc,Result.CallingConvention);
 end;
 
-procedure TTestProcedureTypeParser.DoTestProcedureDecl(CC: TCallingConvention; Const AHint : String);
+Procedure TTestProcedureTypeParser.DoTestProcedureDecl(CC: TCallingConvention;
+  Const AHint: String);
 
 begin
   ParseType('procedure',CC,TPasProcedureType,AHint);
   AssertEquals('Argument count',0,Proc.Args.Count);
+  if AddComment then
+    AssertComment;
 end;
 
-procedure TTestProcedureTypeParser.DoTestProcedureOneArgDecl(
-  CC: TCallingConvention; const AHint: String);
+Procedure TTestProcedureTypeParser.DoTestProcedureOneArgDecl(
+  CC: TCallingConvention; Const AHint: String);
 
 begin
   ParseType('procedure(A : Integer)',CC,TPasProcedureType,AHint);
@@ -749,32 +762,32 @@ begin
   CheckArgument(0,'A','Integer',argDefault);
 end;
 
-procedure TTestProcedureTypeParser.DoTestProcedureOneVarArgDecl(
-  CC: TCallingConvention; const AHint: String);
+Procedure TTestProcedureTypeParser.DoTestProcedureOneVarArgDecl(
+  CC: TCallingConvention; Const AHint: String);
 begin
   ParseType('procedure(var A : Integer)',CC,TPasProcedureType,AHint);
   AssertEquals('Argument count',1,Proc.Args.Count);
   CheckArgument(0,'A','Integer',argVar);
 end;
 
-procedure TTestProcedureTypeParser.DoTestProcedureOneConstArgDecl(
-  CC: TCallingConvention; const AHint: String);
+Procedure TTestProcedureTypeParser.DoTestProcedureOneConstArgDecl(
+  CC: TCallingConvention; Const AHint: String);
 begin
   ParseType('procedure(const A : Integer)',CC,TPasProcedureType,AHint);
   AssertEquals('Argument count',1,Proc.Args.Count);
   CheckArgument(0,'A','Integer',argConst);
 end;
 
-procedure TTestProcedureTypeParser.DoTestProcedureOneOutArgDecl(
-  CC: TCallingConvention; const AHint: String);
+Procedure TTestProcedureTypeParser.DoTestProcedureOneOutArgDecl(
+  CC: TCallingConvention; Const AHint: String);
 begin
   ParseType('procedure(out A : Integer)',CC,TPasProcedureType,AHint);
   AssertEquals('Argument count',1,Proc.Args.Count);
   CheckArgument(0,'A','Integer',argOut);
 end;
 
-procedure TTestProcedureTypeParser.DoTestProcedureTwoArgsDecl(
-  CC: TCallingConvention; const AHint: String);
+Procedure TTestProcedureTypeParser.DoTestProcedureTwoArgsDecl(
+  CC: TCallingConvention; Const AHint: String);
 begin
   ParseType('procedure(A : Integer;B : String)',CC,TPasProcedureType,AHint);
   AssertEquals('Argument count',2,Proc.Args.Count);
@@ -782,8 +795,8 @@ begin
   CheckArgument(1,'B','[TPasAliasType]',argDefault);
 end;
 
-procedure TTestProcedureTypeParser.DoTestProcedureTwoVarArgsDecl(
-  CC: TCallingConvention; const AHint: String);
+Procedure TTestProcedureTypeParser.DoTestProcedureTwoVarArgsDecl(
+  CC: TCallingConvention; Const AHint: String);
 begin
   ParseType('procedure(Var A : Integer;Var B : String)',CC,TPasProcedureType,AHint);
   AssertEquals('Argument count',2,Proc.Args.Count);
@@ -791,8 +804,8 @@ begin
   CheckArgument(1,'B','[TPasAliasType]',argVar);
 end;
 
-procedure TTestProcedureTypeParser.DoTestProcedureTwoConstArgsDecl(
-  CC: TCallingConvention; const AHint: String);
+Procedure TTestProcedureTypeParser.DoTestProcedureTwoConstArgsDecl(
+  CC: TCallingConvention; Const AHint: String);
 begin
   ParseType('procedure(const A : Integer;Const B : String)',CC,TPasProcedureType,AHint);
   AssertEquals('Argument count',2,Proc.Args.Count);
@@ -800,8 +813,8 @@ begin
   CheckArgument(1,'B','[TPasAliasType]',argConst);
 end;
 
-procedure TTestProcedureTypeParser.DoTestProcedureTwoOutArgsDecl(
-  CC: TCallingConvention; const AHint: String);
+Procedure TTestProcedureTypeParser.DoTestProcedureTwoOutArgsDecl(
+  CC: TCallingConvention; Const AHint: String);
 begin
   ParseType('procedure(out A : Integer;Out B : String)',CC,TPasProcedureType,AHint);
   AssertEquals('Argument count',2,Proc.Args.Count);
@@ -809,8 +822,8 @@ begin
   CheckArgument(1,'B','[TPasAliasType]',argOut);
 end;
 
-procedure TTestProcedureTypeParser.DoTestProcedureTwoCombinedArgsDecl(
-  CC: TCallingConvention; const AHint: String);
+Procedure TTestProcedureTypeParser.DoTestProcedureTwoCombinedArgsDecl(
+  CC: TCallingConvention; Const AHint: String);
 begin
   ParseType('procedure(A,B : Integer)',CC,TPasProcedureType,AHint);
   AssertEquals('Argument count',2,Proc.Args.Count);
@@ -818,8 +831,8 @@ begin
   CheckArgument(1,'B','Integer',argDefault);
 end;
 
-procedure TTestProcedureTypeParser.DoTestProcedureTwoCombinedVarArgsDecl(
-  CC: TCallingConvention; const AHint: String);
+Procedure TTestProcedureTypeParser.DoTestProcedureTwoCombinedVarArgsDecl(
+  CC: TCallingConvention; Const AHint: String);
 begin
   ParseType('procedure(Var A,B : Integer)',CC,TPasProcedureType,AHint);
   AssertEquals('Argument count',2,Proc.Args.Count);
@@ -827,8 +840,8 @@ begin
   CheckArgument(1,'B','Integer',argVar);
 end;
 
-procedure TTestProcedureTypeParser.DoTestProcedureTwoCombinedConstArgsDecl(
-  CC: TCallingConvention; const AHint: String);
+Procedure TTestProcedureTypeParser.DoTestProcedureTwoCombinedConstArgsDecl(
+  CC: TCallingConvention; Const AHint: String);
 begin
   ParseType('procedure(Const A,B : Integer)',CC,TPasProcedureType,AHint);
   AssertEquals('Argument count',2,Proc.Args.Count);
@@ -836,8 +849,8 @@ begin
   CheckArgument(1,'B','Integer',argConst);
 end;
 
-procedure TTestProcedureTypeParser.DoTestProcedureTwoCombinedOutArgsDecl(
-  CC: TCallingConvention; const AHint: String);
+Procedure TTestProcedureTypeParser.DoTestProcedureTwoCombinedOutArgsDecl(
+  CC: TCallingConvention; Const AHint: String);
 begin
   ParseType('procedure(Out A,B : Integer)',CC,TPasProcedureType,AHint);
   AssertEquals('Argument count',2,Proc.Args.Count);
@@ -845,8 +858,8 @@ begin
   CheckArgument(1,'B','Integer',argOut);
 end;
 
-procedure TTestProcedureTypeParser.DoTestProcedureDefaultConstArgsDecl(
-  CC: TCallingConvention; const AHint: String);
+Procedure TTestProcedureTypeParser.DoTestProcedureDefaultConstArgsDecl(
+  CC: TCallingConvention; Const AHint: String);
 begin
   ParseType('procedure(A : Integer; Const B : Integer)',CC,TPasProcedureType,AHint);
   AssertEquals('Argument count',2,Proc.Args.Count);
@@ -854,8 +867,8 @@ begin
   CheckArgument(1,'B','Integer',argConst);
 end;
 
-procedure TTestProcedureTypeParser.TestCallingConventions(
-  Proc: TCallingConventionTest; Const AHint : String);
+Procedure TTestProcedureTypeParser.TestCallingConventions(
+  Proc: TCallingConventionTest; Const AHint: String);
 
 Var
   CC : TCallingConvention;
@@ -873,7 +886,7 @@ begin
     end;
 end;
 
-procedure TTestProcedureTypeParser.TestCallingConventions(
+Procedure TTestProcedureTypeParser.TestCallingConventions(
   Proc: TCallingConventionTest);
 begin
   TestCallingConventions(Proc,'');
@@ -883,197 +896,204 @@ begin
   TestCallingConventions(Proc,'platform');
 end;
 
-function TTestProcedureTypeParser.FuncProc: TPasFunctionType;
+Function TTestProcedureTypeParser.FuncProc: TPasFunctionType;
 begin
   Result:=Proc as TPasFunctionType;
 end;
 
-procedure TTestProcedureTypeParser.TestProcedure;
+Procedure TTestProcedureTypeParser.TestProcedure;
 begin
   TestCallingConventions(@DoTestProcedureDecl);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureOneArg;
+Procedure TTestProcedureTypeParser.TestProcedureComment;
+begin
+  AddComment:=True;
+  TestCallingConventions(@DoTestProcedureDecl);
+
+end;
+
+Procedure TTestProcedureTypeParser.TestProcedureOneArg;
 begin
   TestCallingConventions(@DoTestProcedureOneArgDecl);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureOneVarArg;
+Procedure TTestProcedureTypeParser.TestProcedureOneVarArg;
 begin
   TestCallingConventions(@DoTestProcedureOneVarArgDecl);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureOneConstArg;
+Procedure TTestProcedureTypeParser.TestProcedureOneConstArg;
 begin
   TestCallingConventions(@DoTestProcedureOneConstArgDecl);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureOneOutArg;
+Procedure TTestProcedureTypeParser.TestProcedureOneOutArg;
 begin
   TestCallingConventions(@DoTestProcedureOneOutArgDecl);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureTwoArgs;
+Procedure TTestProcedureTypeParser.TestProcedureTwoArgs;
 begin
   TestCallingConventions(@DoTestProcedureTwoArgsDecl);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureTwoVarArgs;
+Procedure TTestProcedureTypeParser.TestProcedureTwoVarArgs;
 begin
   TestCallingConventions(@DoTestProcedureTwoVarArgsDecl);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureTwoConstArgs;
+Procedure TTestProcedureTypeParser.TestProcedureTwoConstArgs;
 begin
   TestCallingConventions(@DoTestProcedureTwoConstArgsDecl);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureTwoOutArgs;
+Procedure TTestProcedureTypeParser.TestProcedureTwoOutArgs;
 begin
   TestCallingConventions(@DoTestProcedureTwoOutArgsDecl);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureTwoCombinedArgs;
+Procedure TTestProcedureTypeParser.TestProcedureTwoCombinedArgs;
 begin
   TestCallingConventions(@DoTestProcedureTwoCombinedArgsDecl);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureTwoCombinedVarArgs;
+Procedure TTestProcedureTypeParser.TestProcedureTwoCombinedVarArgs;
 begin
   TestCallingConventions(@DoTestProcedureTwoCombinedVarArgsDecl);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureTwoCombinedConstArgs;
+Procedure TTestProcedureTypeParser.TestProcedureTwoCombinedConstArgs;
 begin
   TestCallingConventions(@DoTestProcedureTwoCombinedConstArgsDecl);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureTwoCombinedOutArgs;
+Procedure TTestProcedureTypeParser.TestProcedureTwoCombinedOutArgs;
 begin
   TestCallingConventions(@DoTestProcedureTwoCombinedOutArgsDecl);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureDefaultConstArgs;
+Procedure TTestProcedureTypeParser.TestProcedureDefaultConstArgs;
 begin
   TestCallingConventions(@DoTestProcedureDefaultConstArgsDecl);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureUntypedArg;
+Procedure TTestProcedureTypeParser.TestProcedureUntypedArg;
 begin
   TestCallingConventions(@DoTestProcedureUntypedArgDecl);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureUntypedConstArg;
+Procedure TTestProcedureTypeParser.TestProcedureUntypedConstArg;
 begin
   TestCallingConventions(@DoTestProcedureUntypedConstArgDecl);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureUntypedOutArg;
+Procedure TTestProcedureTypeParser.TestProcedureUntypedOutArg;
 begin
   TestCallingConventions(@DoTestProcedureUntypedOutArgDecl);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureUntypedDefArg;
+Procedure TTestProcedureTypeParser.TestProcedureUntypedDefArg;
 begin
   AssertException('No untyped arg by value',EParserError,@DoTestProcedureUntypedDefArg)
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureOneArgDefault;
+Procedure TTestProcedureTypeParser.TestProcedureOneArgDefault;
 begin
   TestCallingConventions(@DoTestProcedureOneArgDefault);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureOneArgDefaultExpr;
+Procedure TTestProcedureTypeParser.TestProcedureOneArgDefaultExpr;
 begin
   TestCallingConventions(@DoTestProcedureOneArgDefaultExpr);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureOneArgDefaultSet;
+Procedure TTestProcedureTypeParser.TestProcedureOneArgDefaultSet;
 begin
   TestCallingConventions(@DoTestProcedureOneArgDefaultSet);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureOneVarArgDefault;
+Procedure TTestProcedureTypeParser.TestProcedureOneVarArgDefault;
 begin
   TestCallingConventions(@DoTestProcedureOneVarArgDefault);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureOneConstArgDefault;
+Procedure TTestProcedureTypeParser.TestProcedureOneConstArgDefault;
 begin
   TestCallingConventions(@DoTestProcedureOneConstArgDefault);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureOneOutArgDefault;
+Procedure TTestProcedureTypeParser.TestProcedureOneOutArgDefault;
 begin
   TestCallingConventions(@DoTestProcedureOneOutArgDefault);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureNoMultiArgDefaults;
+Procedure TTestProcedureTypeParser.TestProcedureNoMultiArgDefaults;
 begin
   AssertParseTypeError('procedure (A,B : Integer = 1)');
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureOpenArray;
+Procedure TTestProcedureTypeParser.TestProcedureOpenArray;
 begin
   TestCallingConventions(@DoTestProcedureOpenArray);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureConstOpenArray;
+Procedure TTestProcedureTypeParser.TestProcedureConstOpenArray;
 begin
   TestCallingConventions(@DoTestProcedureConstOpenArray);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureOutOpenArray;
+Procedure TTestProcedureTypeParser.TestProcedureOutOpenArray;
 begin
   TestCallingConventions(@DoTestProcedureVarOpenArray);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureVarOpenArray;
+Procedure TTestProcedureTypeParser.TestProcedureVarOpenArray;
 begin
   TestCallingConventions(@DoTestProcedureOutOpenArray);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureArrayOfConst;
+Procedure TTestProcedureTypeParser.TestProcedureArrayOfConst;
 begin
   TestCallingConventions(@DoTestProcedureArrayOfConst);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureOfObject;
+Procedure TTestProcedureTypeParser.TestProcedureOfObject;
 begin
   TestCallingConventions(@DoTestProcedureOfObject);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureOfObjectOneArg;
+Procedure TTestProcedureTypeParser.TestProcedureOfObjectOneArg;
 begin
   TestCallingConventions(@DoTestProcedureOfObjectOneArg);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureIsNested;
+Procedure TTestProcedureTypeParser.TestProcedureIsNested;
 begin
   TestCallingConventions(@DoTestProcedureIsNested);
 end;
 
-procedure TTestProcedureTypeParser.TestProcedureIsNesteOneArg;
+Procedure TTestProcedureTypeParser.TestProcedureIsNesteOneArg;
 begin
   TestCallingConventions(@DoTestProcedureIsNestedOneArg);
 end;
 
-procedure TTestProcedureTypeParser.TestFunction;
+Procedure TTestProcedureTypeParser.TestFunction;
 begin
   TestCallingConventions(@DoTestFunction);
 end;
 
-procedure TTestProcedureTypeParser.TestFunctionOneArg;
+Procedure TTestProcedureTypeParser.TestFunctionOneArg;
 begin
   TestCallingConventions(@DoTestFunctionOneArg);
 end;
 
-procedure TTestProcedureTypeParser.TestFunctionOfObject;
+Procedure TTestProcedureTypeParser.TestFunctionOfObject;
 begin
   TestCallingConventions(@DoTestFunctionOfObject);
 end;
 
-procedure TTestProcedureTypeParser.TestFunctionOneArgOfObject;
+Procedure TTestProcedureTypeParser.TestFunctionOneArgOfObject;
 begin
   TestCallingConventions(@DoTestFunctionOneArgOfObject);
 
@@ -1081,7 +1101,7 @@ end;
 
 { TTestRecordTypeParser }
 
-function TTestRecordTypeParser.GetField(AIndex: Integer; R: TPasRecordType
+Function TTestRecordTypeParser.GetField(AIndex: Integer; R: TPasRecordType
   ): TPasVariable;
 begin
   AssertNotNull(R);
@@ -1091,7 +1111,7 @@ begin
   Result:=TPasVariable(R.Members[AIndex]);
 end;
 
-function TTestRecordTypeParser.GetField(AIndex: Integer; R: TPasVariant
+Function TTestRecordTypeParser.GetField(AIndex: Integer; R: TPasVariant
   ): TPasVariable;
 begin
   AssertNotNull(R);
@@ -1112,7 +1132,7 @@ begin
   Result:=TheType as TPasRecordType;
 end;
 
-function TTestRecordTypeParser.GetVariant(AIndex: Integer; R: TPasRecordType
+Function TTestRecordTypeParser.GetVariant(AIndex: Integer; R: TPasRecordType
   ): TPasVariant;
 begin
   AssertNotNull(R);
@@ -1127,7 +1147,7 @@ begin
   Result:=GetVariant(AIndex,GetR);
 end;
 
-procedure TTestRecordTypeParser.TestFields(const Fields: array of string;
+Procedure TTestRecordTypeParser.TestFields(Const Fields: Array of string;
   AHint: String; HaveVariant: Boolean);
 
 Var
@@ -1157,6 +1177,8 @@ begin
     AssertNull('No variant type',TheRecord.VariantType);
     AssertEquals('No variant name','',TheRecord.VariantName);
     end;
+  if AddComment then
+    AssertComment;
 end;
 
 procedure TTestRecordTypeParser.AssertVariantSelector(AName,AType : string);
@@ -1171,7 +1193,7 @@ begin
 end;
 
 
-procedure TTestRecordTypeParser.DoTestEmpty(const AHint: String);
+Procedure TTestRecordTypeParser.DoTestEmpty(Const AHint: String);
 begin
   TestFields([],AHint);
   AssertNotNull('Have members array',TheRecord.Members);
@@ -1185,7 +1207,7 @@ end;
 
 
 procedure TTestRecordTypeParser.AssertVariant1(Hints: TPasMemberHints;
-  VariantLabels: array of string);
+  VariantLabels: Array of string);
 
 Var
   I : Integer;
@@ -1226,7 +1248,7 @@ begin
 end;
 
 procedure TTestRecordTypeParser.AssertVariant2(Hints: TPasMemberHints;
-  VariantLabels: array of string);
+  VariantLabels: Array of string);
 
 Var
   I : Integer;
@@ -1261,7 +1283,7 @@ begin
   AssertTrue('Field 1 hints match',TPasVariable(Variant2.Members.Members[0]).Hints=Hints)
 end;
 
-procedure TTestRecordTypeParser.DoTestVariantNoStorage(const AHint: string);
+procedure TTestRecordTypeParser.DoTestVariantNoStorage(Const AHint: string);
 begin
   TestFields(['x : integer;','case integer of','0 : (y : integer;)'],AHint,True);
   AssertField1([]);
@@ -1270,7 +1292,7 @@ begin
 end;
 
 procedure TTestRecordTypeParser.DoTestDeprecatedVariantNoStorage(
-  const AHint: string);
+  Const AHint: string);
 begin
   TestFields(['x : integer;','case integer of','0 : (y : integer deprecated;)'],AHint,True);
   AssertField1([]);
@@ -1279,7 +1301,7 @@ begin
 end;
 
 procedure TTestRecordTypeParser.DoTestDeprecatedVariantStorage(
-  const AHint: string);
+  Const AHint: string);
 begin
   TestFields(['x : integer;','case s : integer of','0 : (y : integer deprecated;)'],AHint,True);
   AssertField1([]);
@@ -1287,7 +1309,7 @@ begin
   AssertVariant1([hDeprecated]);
 end;
 
-procedure TTestRecordTypeParser.DoTestVariantStorage(const AHint: string);
+procedure TTestRecordTypeParser.DoTestVariantStorage(Const AHint: string);
 begin
   TestFields(['x : integer;','case s : integer of','0 : (y : integer;)'],AHint,True);
   AssertField1([]);
@@ -1295,8 +1317,7 @@ begin
   AssertVariant1([]);
 end;
 
-procedure TTestRecordTypeParser.DoTestTwoVariantsNoStorage(const AHint: string
-  );
+procedure TTestRecordTypeParser.DoTestTwoVariantsNoStorage(Const AHint: string);
 begin
   TestFields(['x : integer;','case integer of','0 : (y : integer;);','1 : (z : integer;)'],AHint,True);
   AssertField1([]);
@@ -1305,7 +1326,7 @@ begin
   AssertVariant2([]);
 end;
 
-procedure TTestRecordTypeParser.DoTestTwoVariantsStorage(const AHint: string);
+procedure TTestRecordTypeParser.DoTestTwoVariantsStorage(Const AHint: string);
 begin
   TestFields(['x : integer;','case s : integer of','0 : (y : integer;);','1 : (z : integer;)'],AHint,True);
   AssertField1([]);
@@ -1315,7 +1336,7 @@ begin
 end;
 
 procedure TTestRecordTypeParser.DoTestTwoVariantsFirstDeprecatedStorage(
-  const AHint: string);
+  Const AHint: string);
 begin
   TestFields(['x : integer;','case s : integer of','0 : (y : integer deprecated;);','1 : (z : integer;)'],AHint,True);
   AssertField1([]);
@@ -1325,7 +1346,7 @@ begin
 end;
 
 procedure TTestRecordTypeParser.DoTestTwoVariantsSecondDeprecatedStorage(
-  const AHint: string);
+  Const AHint: string);
 begin
   TestFields(['x : integer;','case s : integer of','0 : (y : integer ;);','1 : (z : integer deprecated;)'],AHint,True);
   AssertField1([]);
@@ -1334,7 +1355,7 @@ begin
   AssertVariant2([hdeprecated]);
 end;
 
-procedure TTestRecordTypeParser.DoTestVariantTwoLabels(const AHint: string);
+Procedure TTestRecordTypeParser.DoTestVariantTwoLabels(Const AHint: string);
 begin
   TestFields(['x : integer;','case integer of','0,1 : (y : integer)'],AHint,True);
   AssertField1([]);
@@ -1342,8 +1363,7 @@ begin
   AssertVariant1([],['0','1']);
 end;
 
-procedure TTestRecordTypeParser.DoTestTwoVariantsTwoLabels(const AHint: string
-  );
+Procedure TTestRecordTypeParser.DoTestTwoVariantsTwoLabels(Const AHint: string);
 begin
   TestFields(['x : integer;','case integer of','0,1 : (y : integer);','2,3 : (z : integer);'],AHint,True);
   AssertField1([]);
@@ -1352,7 +1372,7 @@ begin
   AssertVariant2([],['2','3']);
 end;
 
-procedure TTestRecordTypeParser.DoTestVariantNestedRecord(const AHint: string);
+procedure TTestRecordTypeParser.DoTestVariantNestedRecord(Const AHint: string);
 begin
   TestFields(['x : integer;','case integer of','0 : ( y : record','  z : integer;','end)'],AHint,True);
   AssertField1([]);
@@ -1360,8 +1380,7 @@ begin
   AssertRecordVariant(0,[],['0']);
 end;
 
-procedure TTestRecordTypeParser.DoTestVariantNestedVariant(const AHint: string
-  );
+procedure TTestRecordTypeParser.DoTestVariantNestedVariant(Const AHint: string);
 begin
   TestFields(['x : integer;','case integer of','0 : ( y : record','  z : integer;','  case byte of ','    1 : (i : integer);','    2 : ( j :  byte)', 'end)'],AHint,True);
   AssertField1([]);
@@ -1372,7 +1391,7 @@ begin
 end;
 
 procedure TTestRecordTypeParser.DoTestVariantNestedVariantFirstDeprecated(
-  const AHint: string);
+  Const AHint: string);
 begin
   TestFields(['x : integer;','case integer of','0 : ( y : record','  z : integer;','  case byte of ','    1 : (i : integer deprecated);','    2 : ( j :  byte)', 'end)'],AHint,True);
   AssertField1([]);
@@ -1404,17 +1423,23 @@ begin
   AssertRecordVariantVariant(1,'j','Byte',[hDeprecated],['2'])
 end;
 
-procedure TTestRecordTypeParser.TestEmpty;
+Procedure TTestRecordTypeParser.TestEmpty;
 begin
   DoTestEmpty('')
 end;
 
-procedure TTestRecordTypeParser.TestEmptyDeprecated;
+Procedure TTestRecordTypeParser.TestEmptyComment;
+begin
+  AddComment:=True;
+  TestEmpty;
+end;
+
+Procedure TTestRecordTypeParser.TestEmptyDeprecated;
 begin
   DoTestEmpty('Deprecated')
 end;
 
-procedure TTestRecordTypeParser.TestEmptyPlatform;
+Procedure TTestRecordTypeParser.TestEmptyPlatform;
 begin
   DoTestEmpty('Platform')
 end;
@@ -1453,17 +1478,6 @@ begin
   AssertTrue('Method hints match',P.Hints=Hints)
 end;
 
-procedure TTestRecordTypeParser.AssertProperty2(Hints: TPasMemberHints);
-Var
-  P : TPasProperty;
-
-begin
-  AssertEquals('Member 2 type',TPasProperty,TObject(TheRecord.Members[1]).ClassType);
-  P:=TPasProperty(TheRecord.Members[1]);
-  AssertEquals('Property name','something',P.Name);
-  AssertTrue('Property hints match',P.Hints=Hints);
-end;
-
 procedure TTestRecordTypeParser.AssertOneIntegerField(Hints : TPasMemberHints);
 
 begin
@@ -1510,7 +1524,7 @@ begin
 end;
 
 procedure TTestRecordTypeParser.AssertRecordVariant(AIndex: Integer;
-  Hints: TPasMemberHints; VariantLabels: array of string);
+  Hints: TPasMemberHints; VariantLabels: Array of string);
 
 Var
   F : TPasVariant;
@@ -1542,9 +1556,9 @@ begin
 
 end;
 
-procedure TTestRecordTypeParser.AssertRecordVariantVariant(AIndex: Integer;
-  const AFieldName, ATypeName: string; Hints: TPasMemberHints;
-  VariantLabels: array of string);
+Procedure TTestRecordTypeParser.AssertRecordVariantVariant(AIndex: Integer;
+  Const AFieldName, ATypeName: string; Hints: TPasMemberHints;
+  VariantLabels: Array of string);
 
 Var
   F : TPasVariant;
@@ -1584,80 +1598,88 @@ begin
   AssertTrue(MN+'hints match',V.Hints=Hints);
 end;
 
-procedure TTestRecordTypeParser.TestOneField;
+Procedure TTestRecordTypeParser.TestOneField;
 begin
   TestFields(['x : integer'],'',False);
   AssertOneIntegerField([]);
 end;
 
-procedure TTestRecordTypeParser.TestOneFieldDeprecated;
+Procedure TTestRecordTypeParser.TestOneFieldComment;
+begin
+  AddComment:=True;
+  TestFields(['{a} x : integer'],'',False);
+  AssertOneIntegerField([]);
+  AssertEquals('Member 1 comment','a'+sLineBreak,TPAsElement(TheRecord.Members[0]).DocComment);
+end;
+
+Procedure TTestRecordTypeParser.TestOneFieldDeprecated;
 begin
   TestFields(['x : integer'],'deprecated',False);
   AssertOneIntegerField([]);
 end;
 
-procedure TTestRecordTypeParser.TestOneFieldPlatform;
+Procedure TTestRecordTypeParser.TestOneFieldPlatform;
 begin
   TestFields(['x : integer'],'platform',False);
   AssertOneIntegerField([]);
 end;
 
-procedure TTestRecordTypeParser.TestOneFieldSemicolon;
+Procedure TTestRecordTypeParser.TestOneFieldSemicolon;
 begin
   TestFields(['x : integer;'],'',False);
   AssertOneIntegerField([]);
 end;
 
-procedure TTestRecordTypeParser.TestOneFieldSemicolonDeprecated;
+Procedure TTestRecordTypeParser.TestOneFieldSemicolonDeprecated;
 begin
   TestFields(['x : integer;'],'deprecated',False);
   AssertOneIntegerField([]);
 
 end;
 
-procedure TTestRecordTypeParser.TestOneFieldSemicolonPlatform;
+Procedure TTestRecordTypeParser.TestOneFieldSemicolonPlatform;
 begin
   TestFields(['x : integer;'],'platform',False);
   AssertOneIntegerField([]);
 end;
 
-procedure TTestRecordTypeParser.TestOneDeprecatedField;
+Procedure TTestRecordTypeParser.TestOneDeprecatedField;
 begin
   TestFields(['x : integer deprecated;'],'',False);
   AssertOneIntegerField([hDeprecated]);
 end;
 
-procedure TTestRecordTypeParser.TestOneDeprecatedFieldDeprecated;
+Procedure TTestRecordTypeParser.TestOneDeprecatedFieldDeprecated;
 begin
   TestFields(['x : integer deprecated;'],'deprecated',False);
   AssertOneIntegerField([hDeprecated]);
 end;
 
-procedure TTestRecordTypeParser.TestOneDeprecatedFieldPlatform;
+Procedure TTestRecordTypeParser.TestOneDeprecatedFieldPlatform;
 begin
   TestFields(['x : integer deprecated;'],'platform',False);
   AssertOneIntegerField([hDeprecated]);
 end;
 
-procedure TTestRecordTypeParser.TestOnePlatformField;
+Procedure TTestRecordTypeParser.TestOnePlatformField;
 begin
   TestFields(['x : integer platform;'],'',False);
   AssertOneIntegerField([hplatform]);
 end;
 
-procedure TTestRecordTypeParser.TestOnePlatformFieldDeprecated;
+Procedure TTestRecordTypeParser.TestOnePlatformFieldDeprecated;
 begin
   TestFields(['x : integer platform;'],'Deprecated',False);
   AssertOneIntegerField([hplatform]);
 end;
 
-procedure TTestRecordTypeParser.TestOnePlatformFieldPlatform;
+Procedure TTestRecordTypeParser.TestOnePlatformFieldPlatform;
 begin
   TestFields(['x : integer platform;'],'Platform',False);
   AssertOneIntegerField([hplatform]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoFields;
+Procedure TTestRecordTypeParser.TestTwoFields;
 begin
   TestFields(['x : integer;','y : integer'],'',False);
   AssertTwoIntegerFields([],[]);
@@ -1693,7 +1715,7 @@ begin
     Fail('Wrong exception class.');
 end;
 
-procedure TTestRecordTypeParser.TestTwoFieldPrivate;
+Procedure TTestRecordTypeParser.TestTwoFieldPrivate;
 begin
   Scanner.Options:=[po_Delphi];
   TestFields(['private','x,y : integer'],'',False);
@@ -1707,115 +1729,115 @@ begin
   AssertTwoIntegerFields([],[]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoFieldDeprecated;
+Procedure TTestRecordTypeParser.TestTwoFieldDeprecated;
 begin
   TestFields(['x : integer;','y : integer'],'deprecated',False);
   AssertTwoIntegerFields([],[]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoFieldPlatform;
+Procedure TTestRecordTypeParser.TestTwoFieldPlatform;
 begin
   TestFields(['x : integer;','y : integer'],'platform',False);
   AssertTwoIntegerFields([],[]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoFieldsFirstDeprecated;
+Procedure TTestRecordTypeParser.TestTwoFieldsFirstDeprecated;
 begin
   TestFields(['x : integer deprecated;','y : integer'],'',False);
   AssertTwoIntegerFields([hdeprecated],[]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoFieldsFirstDeprecatedDeprecated;
+Procedure TTestRecordTypeParser.TestTwoFieldsFirstDeprecatedDeprecated;
 begin
   TestFields(['x : integer deprecated;','y : integer'],'deprecated',False);
   AssertTwoIntegerFields([hdeprecated],[]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoFieldsFirstDeprecatedPlatform;
+Procedure TTestRecordTypeParser.TestTwoFieldsFirstDeprecatedPlatform;
 begin
   TestFields(['x : integer deprecated;','y : integer'],'platform',False);
   AssertTwoIntegerFields([hdeprecated],[]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoFieldsSecondDeprecated;
+Procedure TTestRecordTypeParser.TestTwoFieldsSecondDeprecated;
 begin
   TestFields(['x : integer;','y : integer deprecated;'],'',False);
   AssertTwoIntegerFields([],[hdeprecated]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoFieldsSecondDeprecatedDeprecated;
+Procedure TTestRecordTypeParser.TestTwoFieldsSecondDeprecatedDeprecated;
 begin
   TestFields(['x : integer;','y : integer deprecated;'],'deprecated',False);
   AssertTwoIntegerFields([],[hdeprecated]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoFieldsSecondDeprecatedPlatform;
+Procedure TTestRecordTypeParser.TestTwoFieldsSecondDeprecatedPlatform;
 begin
   TestFields(['x : integer;','y : integer deprecated;'],'platform',False);
   AssertTwoIntegerFields([],[hdeprecated]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoFieldsBothDeprecated;
+Procedure TTestRecordTypeParser.TestTwoFieldsBothDeprecated;
 begin
   TestFields(['x : integer deprecated;','y : integer deprecated;'],'',False);
   AssertTwoIntegerFields([hdeprecated],[hdeprecated]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoFieldsBothDeprecatedDeprecated;
+Procedure TTestRecordTypeParser.TestTwoFieldsBothDeprecatedDeprecated;
 begin
   TestFields(['x : integer deprecated;','y : integer deprecated;'],'deprecated',False);
   AssertTwoIntegerFields([hdeprecated],[hdeprecated]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoFieldsBothDeprecatedPlatform;
+Procedure TTestRecordTypeParser.TestTwoFieldsBothDeprecatedPlatform;
 begin
   TestFields(['x : integer deprecated;','y : integer deprecated;'],'platform',False);
   AssertTwoIntegerFields([hdeprecated],[hdeprecated]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoFieldsCombined;
+Procedure TTestRecordTypeParser.TestTwoFieldsCombined;
 begin
   TestFields(['x,y : integer;'],'',False);
   AssertTwoIntegerFields([],[]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoFieldsCombinedDeprecated;
+Procedure TTestRecordTypeParser.TestTwoFieldsCombinedDeprecated;
 begin
   TestFields(['x,y : integer;'],'deprecated',False);
   AssertTwoIntegerFields([],[]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoFieldsCombinedPlatform;
+Procedure TTestRecordTypeParser.TestTwoFieldsCombinedPlatform;
 begin
   TestFields(['x,y : integer;'],'platform',False);
   AssertTwoIntegerFields([],[]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoDeprecatedFieldsCombined;
+Procedure TTestRecordTypeParser.TestTwoDeprecatedFieldsCombined;
 begin
   TestFields(['x,y : integer deprecated;'],'',False);
   AssertTwoIntegerFields([hdeprecated],[hdeprecated]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoDeprecatedFieldsCombinedDeprecated;
+Procedure TTestRecordTypeParser.TestTwoDeprecatedFieldsCombinedDeprecated;
 begin
   TestFields(['x,y : integer deprecated;'],'deprecated',False);
   AssertTwoIntegerFields([hdeprecated],[hdeprecated]);
 end;
 
-procedure TTestRecordTypeParser.TestTwoDeprecatedFieldsCombinedPlatform;
+Procedure TTestRecordTypeParser.TestTwoDeprecatedFieldsCombinedPlatform;
 begin
   TestFields(['x,y : integer deprecated;'],'platform',False);
   AssertTwoIntegerFields([hdeprecated],[hdeprecated]);
 end;
 
-procedure TTestRecordTypeParser.TestFieldAndMethod;
+Procedure TTestRecordTypeParser.TestFieldAndMethod;
 begin
   TestFields(['x : integer;','procedure dosomething2;'],'',False);
   AssertIntegerFieldAndMethod([],[]);
 end;
 
-procedure TTestRecordTypeParser.TestFieldAnd2Methods;
+Procedure TTestRecordTypeParser.TestFieldAnd2Methods;
 Var
   P : TPasFunction;
 
@@ -1832,26 +1854,7 @@ begin
   AssertEquals('Method 2 result type','Integer', P.FuncType.ResultEl.ResultType.Name);
 end;
 
-procedure TTestRecordTypeParser.TestFieldAndProperty;
-
-begin
-  TestFields(['x : integer;','property something read x write f;'],'',False);
-  AssertEquals('Member count',2,TheRecord.Members.Count);
-  AssertField1([]);
-  AssertProperty2([]);
-end;
-
-procedure TTestRecordTypeParser.TestVisibilityAndMethods;
-begin
-  ParseType('record '+slineBreak+
-    'private '+slineBreak+
-    'function something: integer; '+slineBreak+
-    'public '+slineBreak+
-    'x : integer; '+slineBreak+
-    'end',TPasRecordType,'');
-end;
-
-procedure TTestRecordTypeParser.TestNested;
+Procedure TTestRecordTypeParser.TestNested;
 begin
   TestFields(['x : integer;','y : record','  z : integer;','end'],'',False);
   AssertField1([]);
@@ -1879,14 +1882,14 @@ begin
   AssertRecordField(1,[])
 end;
 
-procedure TTestRecordTypeParser.TestNestedDeprecated;
+Procedure TTestRecordTypeParser.TestNestedDeprecated;
 begin
   TestFields(['x : integer;','y : record','  z : integer;','end'],'deprecated',False);
   AssertField1([]);
   AssertRecordField(1,[])
 end;
 
-procedure TTestRecordTypeParser.TestNestedPlatform;
+Procedure TTestRecordTypeParser.TestNestedPlatform;
 begin
   TestFields(['x : integer;','y : record','  z : integer;','end'],'platform',False);
   AssertField1([]);
@@ -1914,21 +1917,21 @@ begin
   AssertRecordField(0,[])
 end;
 
-procedure TTestRecordTypeParser.TestDeprecatedNested;
+Procedure TTestRecordTypeParser.TestDeprecatedNested;
 begin
   TestFields(['x : integer;','y : record','  z : integer;','end deprecated;'],'',False);
   AssertField1([]);
   AssertRecordField(1,[hdeprecated])
 end;
 
-procedure TTestRecordTypeParser.TestDeprecatedNestedDeprecated;
+Procedure TTestRecordTypeParser.TestDeprecatedNestedDeprecated;
 begin
   TestFields(['x : integer;','y : record','  z : integer;','end deprecated;'],'deprecated',False);
   AssertField1([]);
   AssertRecordField(1,[hdeprecated])
 end;
 
-procedure TTestRecordTypeParser.TestDeprecatedNestedPlatform;
+Procedure TTestRecordTypeParser.TestDeprecatedNestedPlatform;
 begin
   TestFields(['x : integer;','y : record','  z : integer;','end deprecated;'],'platform',False);
   AssertField1([]);
@@ -1956,7 +1959,7 @@ begin
   AssertRecordField(0,[hdeprecated])
 end;
 
-procedure TTestRecordTypeParser.TestVariantNoStorage;
+Procedure TTestRecordTypeParser.TestVariantNoStorage;
 begin
   DoTestVariantNoStorage('');
 end;
@@ -1973,7 +1976,7 @@ begin
   DoTestVariantNoStorage('platform');
 end;
 
-procedure TTestRecordTypeParser.TestVariantStorage;
+Procedure TTestRecordTypeParser.TestVariantStorage;
 begin
   DoTestVariantStorage('');
 end;
@@ -1989,7 +1992,7 @@ begin
   DoTestVariantStorage('platform');
 end;
 
-procedure TTestRecordTypeParser.TestDeprecatedVariantNoStorage;
+Procedure TTestRecordTypeParser.TestDeprecatedVariantNoStorage;
 begin
   DoTestDeprecatedVariantNoStorage('');
 end;
@@ -2004,7 +2007,7 @@ begin
   DoTestDeprecatedVariantNoStorage('Platform');
 end;
 
-procedure TTestRecordTypeParser.TestDeprecatedVariantStorage;
+Procedure TTestRecordTypeParser.TestDeprecatedVariantStorage;
 begin
   DoTestDeprecatedVariantStorage('');
 end;
@@ -2019,7 +2022,7 @@ begin
   DoTestDeprecatedVariantStorage('Platform');
 end;
 
-procedure TTestRecordTypeParser.TestTwoVariantsNoStorage;
+Procedure TTestRecordTypeParser.TestTwoVariantsNoStorage;
 begin
   DoTestTwoVariantsNoStorage('');
 end;
@@ -2034,7 +2037,7 @@ begin
   DoTestTwoVariantsNoStorage('platform');
 end;
 
-procedure TTestRecordTypeParser.TestTwoVariantsStorage;
+Procedure TTestRecordTypeParser.TestTwoVariantsStorage;
 begin
   DoTestTwoVariantsStorage('');
 end;
@@ -2049,7 +2052,7 @@ begin
   DoTestTwoVariantsStorage('platform');
 end;
 
-procedure TTestRecordTypeParser.TestTwoVariantsFirstDeprecatedStorage;
+Procedure TTestRecordTypeParser.TestTwoVariantsFirstDeprecatedStorage;
 begin
   DoTestTwoVariantsFirstDeprecatedStorage('');
 end;
@@ -2064,7 +2067,7 @@ begin
   DoTestTwoVariantsFirstDeprecatedStorage('platform');
 end;
 
-procedure TTestRecordTypeParser.TestTwoVariantsSecondDeprecatedStorage;
+Procedure TTestRecordTypeParser.TestTwoVariantsSecondDeprecatedStorage;
 begin
   DoTestTwoVariantsSecondDeprecatedStorage('');
 end;
@@ -2079,120 +2082,126 @@ begin
   DoTestTwoVariantsSecondDeprecatedStorage('platform');
 end;
 
-procedure TTestRecordTypeParser.TestVariantTwoLabels;
+Procedure TTestRecordTypeParser.TestVariantTwoLabels;
 begin
   DoTestVariantTwoLabels('');
 end;
 
-procedure TTestRecordTypeParser.TestVariantTwoLabelsDeprecated;
+Procedure TTestRecordTypeParser.TestVariantTwoLabelsDeprecated;
 begin
   DoTestVariantTwoLabels('Deprecated');
 end;
 
-procedure TTestRecordTypeParser.TestVariantTwoLabelsPlatform;
+Procedure TTestRecordTypeParser.TestVariantTwoLabelsPlatform;
 begin
   DoTestVariantTwoLabels('Platform');
 end;
 
-procedure TTestRecordTypeParser.TestTwoVariantsTwoLabels;
+Procedure TTestRecordTypeParser.TestTwoVariantsTwoLabels;
 begin
   DoTestTwoVariantsTwoLabels('');
 end;
 
-procedure TTestRecordTypeParser.TestTwoVariantsTwoLabelsDeprecated;
+Procedure TTestRecordTypeParser.TestTwoVariantsTwoLabelsDeprecated;
 begin
   DoTestTwoVariantsTwoLabels('Deprecated');
 end;
 
-procedure TTestRecordTypeParser.TestTwoVariantsTwoLabelsPlatform;
+Procedure TTestRecordTypeParser.TestTwoVariantsTwoLabelsPlatform;
 begin
   DoTestTwoVariantsTwoLabels('Platform');
 end;
 
-procedure TTestRecordTypeParser.TestVariantNestedRecord;
+Procedure TTestRecordTypeParser.TestVariantNestedRecord;
 begin
   DoTestVariantNestedRecord('');
 end;
 
-procedure TTestRecordTypeParser.TestVariantNestedRecordDeprecated;
+Procedure TTestRecordTypeParser.TestVariantNestedRecordDeprecated;
 begin
   DoTestVariantNestedRecord('Deprecated');
 end;
 
-procedure TTestRecordTypeParser.TestVariantNestedRecordPlatform;
+Procedure TTestRecordTypeParser.TestVariantNestedRecordPlatform;
 begin
   DoTestVariantNestedRecord('Platform');
 end;
 
-procedure TTestRecordTypeParser.TestVariantNestedVariant;
+Procedure TTestRecordTypeParser.TestVariantNestedVariant;
 begin
   DoTestVariantNestedVariant('');
 end;
 
-procedure TTestRecordTypeParser.TestVariantNestedVariantDeprecated;
+Procedure TTestRecordTypeParser.TestVariantNestedVariantDeprecated;
 begin
   DoTestVariantNestedVariant('deprecated');
 end;
 
-procedure TTestRecordTypeParser.TestVariantNestedVariantPlatForm;
+Procedure TTestRecordTypeParser.TestVariantNestedVariantPlatForm;
 begin
   DoTestVariantNestedVariant('Platform');
 end;
 
-procedure TTestRecordTypeParser.TestVariantNestedVariantFirstDeprecated;
+Procedure TTestRecordTypeParser.TestVariantNestedVariantFirstDeprecated;
 begin
   DoTestVariantNestedVariantFirstDeprecated('');
 end;
 
-procedure TTestRecordTypeParser.TestVariantNestedVariantFirstDeprecatedDeprecated;
+Procedure TTestRecordTypeParser.TestVariantNestedVariantFirstDeprecatedDeprecated;
 begin
   DoTestVariantNestedVariantFirstDeprecated('deprecated');
 end;
 
-procedure TTestRecordTypeParser.TestVariantNestedVariantFirstDeprecatedPlatform;
+Procedure TTestRecordTypeParser.TestVariantNestedVariantFirstDeprecatedPlatform;
 begin
   DoTestVariantNestedVariantFirstDeprecated('platform');
 end;
 
-procedure TTestRecordTypeParser.TestVariantNestedVariantSecondDeprecated;
+Procedure TTestRecordTypeParser.TestVariantNestedVariantSecondDeprecated;
 begin
   DoTestVariantNestedVariantSecondDeprecated('');
 end;
 
-procedure TTestRecordTypeParser.TestVariantNestedVariantSecondDeprecatedDeprecated;
+Procedure TTestRecordTypeParser.TestVariantNestedVariantSecondDeprecatedDeprecated;
 begin
   DoTestVariantNestedVariantSecondDeprecated('deprecated');
 end;
 
-procedure TTestRecordTypeParser.TestVariantNestedVariantSecondDeprecatedPlatform;
+Procedure TTestRecordTypeParser.TestVariantNestedVariantSecondDeprecatedPlatform;
 begin
   DoTestVariantNestedVariantSecondDeprecated('platform');
 end;
 
-procedure TTestRecordTypeParser.TestVariantNestedVariantBothDeprecated;
+Procedure TTestRecordTypeParser.TestVariantNestedVariantBothDeprecated;
 begin
   DoTestVariantNestedVariantBothDeprecated('');
 end;
 
-procedure TTestRecordTypeParser.TestVariantNestedVariantBothDeprecatedDeprecated;
+Procedure TTestRecordTypeParser.TestVariantNestedVariantBothDeprecatedDeprecated;
 begin
   DoTestVariantNestedVariantBothDeprecated('deprecated');
 end;
 
-procedure TTestRecordTypeParser.TestVariantNestedVariantBothDeprecatedPlatform;
+Procedure TTestRecordTypeParser.TestVariantNestedVariantBothDeprecatedPlatform;
 begin
   DoTestVariantNestedVariantBothDeprecated('platform');
 end;
 
 { TBaseTestTypeParser }
 
-function TBaseTestTypeParser.ParseType(ASource: String; ATypeClass: TClass;Const AHint : String = ''): TPasType;
+Function TBaseTestTypeParser.ParseType(ASource: String; ATypeClass: TClass;
+  Const AHint: String): TPasType;
 
 Var
   D : String;
 begin
   Hint:=AHint;
   Add('Type');
+  If AddComment then
+    begin
+    Add('// A comment');
+    Parser.Engine.NeedComments:=True;
+    end;
   D:='A = '+ASource;
   If Hint<>'' then
     D:=D+' '+Hint;
@@ -2210,7 +2219,7 @@ begin
     CheckHint(TPasMemberHint(Getenumvalue(typeinfo(TPasMemberHint),'h'+Hint)));
 end;
 
-procedure TBaseTestTypeParser.AssertParseTypeError(ASource: String);
+Procedure TBaseTestTypeParser.AssertParseTypeError(ASource: String);
 begin
   try
     ParseType(ASource,Nil,'');
@@ -2220,6 +2229,12 @@ begin
   end;
 end;
 
+Procedure TBaseTestTypeParser.AssertComment;
+begin
+  AssertNotNull('Have type',TheType);
+  AssertEquals('Type comment',' A comment'+sLineBreak,TheTYpe.DocComment);
+end;
+
 procedure TBaseTestTypeParser.SetUp;
 begin
   Inherited;
@@ -2228,7 +2243,7 @@ begin
   FType:=Nil;
 end;
 
-procedure TBaseTestTypeParser.TearDown;
+Procedure TBaseTestTypeParser.TearDown;
 begin
   inherited TearDown;
   FType:=Nil;
@@ -2390,6 +2405,13 @@ begin
   DoTestAliasType('BYTE','');
 end;
 
+Procedure TTestTypeParser.TestSimpleTypeByteComment;
+begin
+  AddComment:=True;
+  DoTestAliasType('BYTE','');
+  AssertComment;
+end;
+
 Procedure TTestTypeParser.TestSimpleTypeByteDeprecated;
 begin
   DoTestAliasType('BYTE','deprecated');
@@ -2656,6 +2678,13 @@ begin
   AssertEquals('Array type','0..2',TPasArrayType(TheType).IndexRange);
 end;
 
+Procedure TTestTypeParser.TestStaticArrayComment;
+begin
+  AddComment:=True;
+  TestStaticArray;
+  AssertComment;
+end;
+
 procedure TTestTypeParser.TestStaticArrayDeprecated;
 begin
   DoParseArray('array [0..2] of integer','deprecated',Nil);
@@ -2687,6 +2716,14 @@ begin
   AssertEquals('Array type','',TPasArrayType(TheType).IndexRange);
 end;
 
+Procedure TTestTypeParser.TestDynamicArrayComment;
+begin
+  AddComment:=True;
+  DoParseArray('array of integer','',Nil);
+  AssertEquals('Array type','',TPasArrayType(TheType).IndexRange);
+  AssertComment;
+end;
+
 Procedure TTestTypeParser.TestSimpleEnumerated;
 
 begin
@@ -2699,6 +2736,25 @@ begin
   AssertEquals('Assigned value third enumerated empty','',TPasEnumValue(TPasEnumType(TheType).Values[2]).AssignedValue);
 end;
 
+Procedure TTestTypeParser.TestSimpleEnumeratedComment;
+begin
+  AddComment:=True;
+  TestSimpleEnumerated;
+  AssertComment;
+  AssertEquals('No comment on enum 0','',TPasEnumValue(TPasEnumType(TheType).Values[0]).DocComment);
+  AssertEquals('No comment on enum 1','',TPasEnumValue(TPasEnumType(TheType).Values[1]).DocComment);
+  AssertEquals('No comment on enum 2','',TPasEnumValue(TPasEnumType(TheType).Values[2]).DocComment);
+end;
+
+Procedure TTestTypeParser.TestSimpleEnumeratedComment2;
+begin
+  AddComment:=True;
+  DoParseEnumerated('( {a} one, {b} two, {c} three)','',3);
+  AssertEquals('comment on enum 0','a'+sLineBreak,TPasEnumValue(TPasEnumType(TheType).Values[0]).DocComment);
+  AssertEquals('comment on enum 1','b'+sLineBreak,TPasEnumValue(TPasEnumType(TheType).Values[1]).DocComment);
+  AssertEquals('comment on enum 2','c'+sLineBreak,TPasEnumValue(TPasEnumType(TheType).Values[2]).DocComment);
+end;
+
 Procedure TTestTypeParser.TestSimpleEnumeratedDeprecated;
 begin
   DoParseEnumerated('(one,two,three)','deprecated',3);
@@ -2868,6 +2924,13 @@ begin
   DoTestClassOf('');
 end;
 
+Procedure TTestTypeParser.TestClassOfComment;
+begin
+  AddComment:=True;
+  DoTestClassOf('');
+  AssertComment;
+end;
+
 Procedure TTestTypeParser.TestClassOfDeprecated;
 begin
   DoTestClassOf('deprecated');
diff --git a/packages/fcl-passrc/tests/testpassrc.lpi b/packages/fcl-passrc/tests/testpassrc.lpi
index 86bdfc7194..429ea12e08 100644
--- a/packages/fcl-passrc/tests/testpassrc.lpi
+++ b/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">