paweld/lazarus
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/lazarus/lazarus.git synced 2025-04-06 03:37:54 +02:00
Code Issues Packages Projects Releases Wiki Activity

codetools: class helpers: find declaration and code completion, patch #28266, from Ondrej Pokorny

Browse Source 
git-svn-id: trunk@49405 -
This commit is contained in:
mattias 2015-06-22 10:02:11 +00:00
parent 102b47f0d1
commit 699bdb9e8f
37 changed files with 1319 additions and 418 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
components/codetools/codecompletiontool.pas
View File

@ -1373,10 +1373,10 @@ begin
// save cursor
OldCursor:=CurPos;
// search identifier
if Params=nil then
Params:=TFindDeclarationParams.Create;
if ContextNode=nil then
ContextNode:=FindDeepestNodeAtPos(CurPos.StartPos,true);
if Params=nil then
Params:=TFindDeclarationParams.Create(Self, ContextNode);
ContextNode := ContextNode.GetNodeOfType(ctnProcedureType);
Params.ContextNode:=ContextNode;
Params.SetIdentifier(Self,@Src[CurPos.StartPos],@CheckSrcIdentifier);
@ -1656,7 +1656,7 @@ begin
// search variable
ActivateGlobalWriteLock;
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create(Self, CursorNode);
try
{$IFDEF VerboseCompleteLocalVarAssign}
DebugLn(' CompleteLocalVariableAssignment: check if variable is already defined ...');
@ -1685,7 +1685,7 @@ begin
begin
Params.SetIdentifier(Self, PChar(NewType), nil);
Params.ContextNode := CursorNode;
Params.Flags := [fdfSearchInAncestors..fdfIgnoreCurContextNode];
Params.Flags := [fdfSearchInAncestors..fdfIgnoreCurContextNode,fdfSearchInHelpers];
if FindIdentifierInContext(Params)
and (Params.NewCodeTool <> ExprType.Context.Tool) then
NewType := ExprType.Context.Tool.ExtractSourceName + '.' + NewType;
@ -1791,7 +1791,7 @@ var
Params.SetIdentifier(Self,@Src[CurPos.StartPos],nil);
fFullTopLvlName:='';
Params.OnTopLvlIdentifierFound:=@OnTopLvlIdentifierFound;
Params.Flags:=[fdfSearchInParentNodes,fdfSearchInAncestors,
Params.Flags:=[fdfSearchInParentNodes,fdfSearchInAncestors,fdfSearchInHelpers,
fdfTopLvlResolving,fdfFindVariable];
if (not FindDeclarationOfIdentAtParam(Params)) then begin
{$IFDEF CTDEBUG}
@ -1808,7 +1808,7 @@ var
PropVarContext:=CreateFindContext(Params);
// identifier is property
// -> check type of property
Params.Flags:=[fdfSearchInParentNodes,fdfSearchInAncestors];
Params.Flags:=[fdfSearchInParentNodes,fdfSearchInAncestors,fdfSearchInHelpers];
ProcContext:=PropVarContext.Tool.FindBaseTypeOfNode(
Params,PropVarContext.Node);
if (ProcContext.Node=nil) or (ProcContext.Node.Desc<>ctnProcedureType)
@ -1979,7 +1979,7 @@ begin
{$ENDIF}
FindProcAndClassNode(ProcNode,AClassNode);
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create(Self, CursorNode);
try
{$IFDEF VerboseCompleteEventAssign}
DebugLn(' CompleteEventAssignment: FindEventTypeAtCursor...');
@ -2091,7 +2091,7 @@ begin
// search variable
ActivateGlobalWriteLock;
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create(Self, CursorNode);
try
{$IFDEF CTDEBUG}
DebugLn(' CompleteLocalVariableForIn: check if variable is already defined ...');
@ -2242,7 +2242,7 @@ begin
{$ENDIF}
// search variable
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create(Self, CursorNode);
try
{$IFDEF CTDEBUG}
DebugLn(' CompleteLocalIdentifierByParameter: check if variable is already defined ...');
@ -2270,40 +2270,54 @@ begin
Params.ContextNode:=Context.Node;
Params.Flags:=fdfDefaultForExpressions+[fdfFunctionResult,fdfFindChildren];
ExprType:=FindExpressionResultType(Params,ProcStartPos,ProcNameAtom.StartPos);
if ExprType.Desc<>xtContext then begin
if not(ExprType.Desc in xtAllIdentTypes) then begin
debugln(['TCodeCompletionCodeTool.CompleteLocalIdentifierByParameter Call="',ExtractCode(ProcStartPos,ProcNameAtom.StartPos,[]),'" gives ',ExprTypeToString(ExprType)]);
exit;
end;
// resolve point '.'
Context:=ExprType.Context;
//debugln(['TCodeCompletionCodeTool.CompleteLocalIdentifierByParameter base class: ',FindContextToString(Context)]);
Params.Clear;
Params.Flags:=fdfDefaultForExpressions;
Context:=Context.Tool.FindBaseTypeOfNode(Params,Context.Node);
{$IFDEF CTDEBUG}
debugln(['TCodeCompletionCodeTool.CompleteLocalVariableByParameter search proc in sub context: ',FindContextToString(Context)]);
{$ENDIF}
if Assigned(Context.Tool) and Assigned(Context.Node) then
begin
// resolve point '.'
//debugln(['TCodeCompletionCodeTool.CompleteLocalIdentifierByParameter base class: ',FindContextToString(Context)]);
Params.Clear;
Params.Flags:=fdfDefaultForExpressions;
Context:=Context.Tool.FindBaseTypeOfNode(Params,Context.Node);
{$IFDEF CTDEBUG}
debugln(['TCodeCompletionCodeTool.CompleteLocalVariableByParameter search proc in sub context: ',FindContextToString(Context)]);
{$ENDIF}
end;
end;
if Assigned(Context.Tool) and Assigned(Context.Node) then
begin
// find declaration of parameter list
// ToDo: search in all overloads for the best fit
Params.ContextNode:=Context.Node;
Params.SetIdentifier(Self,@Src[ProcNameAtom.StartPos],nil);
Params.Flags:=fdfDefaultForExpressions+[fdfFindVariable];
if Context.Node=CursorNode then
Params.Flags:=Params.Flags+[fdfSearchInParentNodes,fdfIgnoreCurContextNode]
else
Params.Flags:=Params.Flags-[fdfSearchInParentNodes,fdfIgnoreCurContextNode];
CleanPosToCodePos(VarNameRange.StartPos,IgnorePos);
IgnoreErrorAfter:=IgnorePos;
try
{$IFDEF CTDEBUG}
debugln(['TCodeCompletionCodeTool.CompleteLocalIdentifierByParameter searching ',GetIdentifier(Params.Identifier),' [',dbgs(Params.Flags),'] in ',FindContextToString(Context)]);
{$ENDIF}
if not Context.Tool.FindIdentifierInContext(Params) then exit;
finally
ClearIgnoreErrorAfter;
end;
end else
if (ExprType.Desc in xtAllIdentPredefinedTypes) then
begin
Params.ContextNode:=CursorNode;
Params.SetIdentifier(Self,@Src[ProcNameAtom.StartPos],nil);
Params.Flags:=fdfDefaultForExpressions+[fdfFindVariable]+
[fdfSearchInParentNodes,fdfIgnoreCurContextNode];
FindIdentifierInBasicTypeHelpers(ExprType.Desc, Params);
end;
// find declaration of parameter list
// ToDo: search in all overloads for the best fit
Params.ContextNode:=Context.Node;
Params.SetIdentifier(Self,@Src[ProcNameAtom.StartPos],nil);
Params.Flags:=fdfDefaultForExpressions+[fdfFindVariable];
if Context.Node=CursorNode then
Params.Flags:=Params.Flags+[fdfSearchInParentNodes,fdfIgnoreCurContextNode]
else
Params.Flags:=Params.Flags-[fdfSearchInParentNodes,fdfIgnoreCurContextNode];
CleanPosToCodePos(VarNameRange.StartPos,IgnorePos);
IgnoreErrorAfter:=IgnorePos;
try
{$IFDEF CTDEBUG}
debugln(['TCodeCompletionCodeTool.CompleteLocalIdentifierByParameter searching ',GetIdentifier(Params.Identifier),' [',dbgs(Params.Flags),'] in ',FindContextToString(Context)]);
{$ENDIF}
if not Context.Tool.FindIdentifierInContext(Params) then exit;
finally
ClearIgnoreErrorAfter;
end;
NewType:='';
MissingUnitName:='';
if Params.NewNode=nil then exit;
@ -2329,7 +2343,7 @@ begin
// search type
Params.Clear;
Params.ContextNode:=TypeNode;
Params.Flags:=[fdfSearchInParentNodes,fdfSearchInAncestors,
Params.Flags:=[fdfSearchInParentNodes,fdfSearchInAncestors,fdfSearchInHelpers,
fdfTopLvlResolving];
AliasType:=CleanFindContext;
ExprType:=TypeTool.FindExpressionResultType(Params,
@ -2682,7 +2696,7 @@ begin
ExprList:=nil;
ParamNames:=nil;
ActivateGlobalWriteLock;
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create(Self, CursorNode);
try
// check parameter list
Params.ContextNode:=CursorNode;
@ -2813,7 +2827,7 @@ const
Params.ContextNode:=CursorNode;
Params.SetIdentifier(Self,@Src[ProcNameAtom.StartPos],@CheckSrcIdentifier);
Params.Flags:=[fdfSearchInParentNodes,
fdfTopLvlResolving,fdfSearchInAncestors,
fdfTopLvlResolving,fdfSearchInAncestors,fdfSearchInHelpers,
fdfIgnoreCurContextNode];
if FindIdentifierInContext(Params) then begin
// proc already exists
@ -2953,7 +2967,7 @@ begin
CheckWholeUnitParsed(CursorNode,BeginNode);
Beauty:=SourceChangeCache.BeautifyCodeOptions;
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create(Self, CursorNode);
ExprList:=nil;
ActivateGlobalWriteLock;
try
@ -5332,6 +5346,7 @@ function TCodeCompletionCodeTool.BuildUnitDefinitionGraph(out
end;
ctnClassInterface, ctnDispinterface, ctnClass, ctnObject, ctnRecordType,
ctnClassHelper, ctnRecordHelper, ctnTypeHelper,
ctnObjCClass, ctnObjCCategory, ctnObjCProtocol, ctnCPPClass:
begin
ChildNode:=SubNode.FirstChild;
@ -5799,7 +5814,7 @@ function TCodeCompletionCodeTool.FindAssignMethod(CursorPos: TCodeXYPosition;
Params: TFindDeclarationParams;
begin
if ClassNode=nil then exit;
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create(Self, ClassNode);
try
Params.Flags:=[fdfSearchInAncestors];
Params.Identifier:=PChar(ProcName);
@ -6074,11 +6089,11 @@ begin
Result:=true;
end;
if VarNode=nil then begin
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create(Self, CursorNode);
try
Params.ContextNode:=CursorNode;
Params.SetIdentifier(Self,Identifier,nil);
Params.Flags:=[fdfSearchInParentNodes,fdfSearchInAncestors,
Params.Flags:=[fdfSearchInParentNodes,fdfSearchInAncestors,fdfSearchInHelpers,
fdfTopLvlResolving,fdfFindVariable];
Result:=FindIdentifierInContext(Params);
VarTool:=Params.NewCodeTool;
@ -6099,7 +6114,7 @@ begin
end;
// resolve type
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create(Self, CursorNode);
try
Params.Flags:=fdfDefaultForExpressions;
if VarNode.Desc in [ctnProcedure,ctnProcedureHead] then
@ -6143,7 +6158,7 @@ begin
AddAssignment('nil');
ctnProcedureHead:
if Tool.NodeIsFunction(Node) then begin
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create(Self, Node);
try
aContext:=Tool.FindBaseTypeOfNode(Params,Node);
Tool:=aContext.Tool;
@ -6284,7 +6299,7 @@ begin
// search identifier
ActivateGlobalWriteLock;
try
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create(Self, CursorNode);
try
{$IFDEF CTDEBUG}
DebugLn(' GuessTypeOfIdentifier: check if variable is already defined ...');
@ -6361,7 +6376,7 @@ begin
debugln(['TCodeCompletionCodeTool.GuessTypeOfIdentifier guessing type of assignment :="',dbgstr(Src,TermAtom.StartPos,TermAtom.EndPos-TermAtom.StartPos),'"']);
// find type of term
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create(Self, CursorNode);
try
Params.ContextNode:=CursorNode;
NewType:=FindTermTypeAsString(TermAtom,Params,NewExprType);
@ -6392,7 +6407,7 @@ begin
debugln(['TCodeCompletionCodeTool.GuessTypeOfIdentifier guessing type of for-in list "',dbgstr(Src,TermAtom.StartPos,TermAtom.EndPos-TermAtom.StartPos),'"']);
// find type of term
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create(Self, CursorNode);
try
NewType:=FindForInTypeAsString(TermAtom,CursorNode,Params,NewExprType);
finally

1
components/codetools/codetoolsstrconsts.pas
View File

@ -82,6 +82,7 @@ ResourceString
crsFoundUnexpectedAt = '%s, found unexpected %s at %s';
ctsAnonymDefinitionsAreNotAllowed = 'Anonymous %s definitions are not allowed';
ctsNestedDefinitionsAreNotAllowed = 'Nested %s definitions are not allowed';
ctsHelperIsNotAllowed = 'Helper after %s is not allowed';
ctsEndForRecordNotFound = 'end for record not found';
ctsMissingEnumList = 'missing enum list';
ctsMissingTypeIdentifier = 'missing type identifier';

19
components/codetools/codetree.pas
View File

@ -91,14 +91,15 @@ const
ctnObjCCategory = 35;
ctnObjCProtocol = 36;
ctnCPPClass = 37;
ctnTypeHelper = 38;
ctnTypeHelper = 38;//"type helper"
ctnRecordHelper = 39;//"record helper"
ctnClassAbstract = 40;
ctnClassSealed = 41;
ctnClassExternal = 42;
ctnClassHelper = 43;
ctnClassHelper = 43;//"class helper"
ctnClassInheritance = 44;
ctnClassHelperFor = 45;
ctnHelperFor = 45;//class/record/type helper for
ctnClassGUID = 46;
ctnClassClassVar = 47; // child of visibility section
ctnClassPrivate = 48; // child of AllClassObjects
@ -167,9 +168,10 @@ const
[ctnConstSection, ctnTypeSection, ctnVarSection, ctnClassClassVar];
AllClassSections =
AllClassBaseSections+AllClassSubSections;
AllClassInterfaces = [ctnClassInterface,ctnDispinterface,ctnObjCProtocol,ctnTypeHelper];
AllClassInterfaces = [ctnClassInterface,ctnDispinterface,ctnObjCProtocol];
AllClassObjects = [ctnClass,ctnObject,ctnRecordType,
ctnObjCClass,ctnObjCCategory,ctnCPPClass];
ctnObjCClass,ctnObjCCategory,ctnCPPClass,
ctnClassHelper,ctnRecordHelper,ctnTypeHelper];
AllClasses = AllClassObjects+AllClassInterfaces;
AllClassModifiers = [ctnClassAbstract, ctnClassSealed, ctnClassExternal];
AllDefinitionSections =
@ -192,7 +194,7 @@ const
ctnInitialization,ctnFinalization];
AllFindContextDescs = AllIdentifierDefinitions + AllCodeSections + AllClasses +
[ctnProcedure];
AllPointContexts = AllClasses+AllSourceTypes+[ctnEnumerationType,ctnInterface,ctnImplementation];
AllPointContexts = AllClasses+AllSourceTypes+[ctnEnumerationType,ctnInterface,ctnImplementation,ctnTypeType];
// CodeTreeNodeSubDescriptors
@ -367,6 +369,7 @@ begin
ctnObjCProtocol: Result:='ObjCProtocol';
ctnCPPClass: Result:='CPPClass';
ctnTypeHelper: Result:='Type Helper';
ctnRecordHelper: Result:='Record Helper';
ctnClassInheritance: Result:='Class inheritance';
ctnClassGUID: Result:='GUID';
@ -380,8 +383,8 @@ begin
ctnClassAbstract: Result:='abstract';
ctnClassSealed: Result:='sealed';
ctnClassExternal: Result:='external';
ctnClassHelper: Result:='helper';
ctnClassHelperFor: Result:='(helper) for';
ctnClassHelper: Result:='Class Helper';
ctnHelperFor: Result:='(helper) for';
ctnProcedure: Result:='Procedure';
ctnProcedureHead: Result:='ProcedureHead';

3
components/codetools/customcodetool.pas
View File

@ -574,7 +574,8 @@ begin
if (SubDesc and ctnsNeedJITParsing)>0 then Result:=ctsUnparsed;
end;
ctnClass,ctnObject,ctnRecordType,ctnObjCClass,ctnObjCCategory,ctnObjCProtocol,
ctnCPPClass,ctnClassInterface,ctnDispinterface:
ctnCPPClass,ctnClassInterface,ctnDispinterface,
ctnTypeHelper,ctnRecordHelper,ctnClassHelper:
begin
Result:='';
if (SubDesc and ctnsForwardDeclaration)>0 then Result:=ctsForward;

86
components/codetools/eventcodetool.pas
View File

@ -532,6 +532,7 @@ var
var TypeName: string;
Params: TFindDeclarationParams;
TypeContext: TFindContext;
CLList: THelpersList;
begin
Result:=CleanFindContext;
if AStartUnitName<>'' then begin
@ -545,48 +546,53 @@ begin
end;
ActivateGlobalWriteLock;
Params:=nil;
try
// find method type declaration
TypeName:=ATypeInfo^.Name;
Params:=TFindDeclarationParams.Create;
CLList := THelpersList.Create;
try
// find method in interface and used units
Params.ContextNode:=FindImplementationNode;
if Params.ContextNode=nil then
Params.ContextNode:=FindMainBeginEndNode;
if Params.ContextNode=nil then begin
MoveCursorToNodeStart(Tree.Root);
RaiseException(Format(ctsIdentifierNotFound,[GetIdentifier(@TypeName[1])]));
// find method type declaration
TypeName:=ATypeInfo^.Name;
Params:=TFindDeclarationParams.Create(CLList);//FindHelpersInContext will be called later
try
// find method in interface and used units
Params.ContextNode:=FindImplementationNode;
if Params.ContextNode=nil then
Params.ContextNode:=FindMainBeginEndNode;
if Params.ContextNode=nil then begin
MoveCursorToNodeStart(Tree.Root);
RaiseException(Format(ctsIdentifierNotFound,[GetIdentifier(@TypeName[1])]));
end;
FindHelpersInContext(Params);
Params.SetIdentifier(Self,@TypeName[1],nil);
Params.Flags:=[fdfExceptionOnNotFound,fdfSearchInParentNodes];
//DebugLn(['TEventsCodeTool.FindMethodTypeInfo TypeName=',TypeName,' MainFilename=',MainFilename]);
FindIdentifierInContext(Params);
// find proc node
if Params.NewNode.Desc<>ctnTypeDefinition then begin
Params.NewCodeTool.MoveCursorToNodeStart(Params.NewNode);
Params.NewCodeTool.RaiseException(ctsMethodTypeDefinitionNotFound);
end;
TypeContext:=CreateFindContext(Params);
finally
Params.Free;
end;
Params.SetIdentifier(Self,@TypeName[1],nil);
Params.Flags:=[fdfExceptionOnNotFound,fdfSearchInParentNodes];
//DebugLn(['TEventsCodeTool.FindMethodTypeInfo TypeName=',TypeName,' MainFilename=',MainFilename]);
FindIdentifierInContext(Params);
// find proc node
if Params.NewNode.Desc<>ctnTypeDefinition then begin
Params.NewCodeTool.MoveCursorToNodeStart(Params.NewNode);
Params.NewCodeTool.RaiseException(ctsMethodTypeDefinitionNotFound);
end;
TypeContext:=CreateFindContext(Params);
finally
Params.Free;
end;
Params:=TFindDeclarationParams.Create;
try
Params.Flags:=[fdfExceptionOnNotFound,fdfSearchInParentNodes];
Result:=TypeContext.Tool.FindBaseTypeOfNode(Params,TypeContext.Node);
if Result.Node=nil then begin
TypeContext.Tool.MoveCursorToNodeStart(TypeContext.Node);
TypeContext.Tool.RaiseException(ctsMethodTypeDefinitionNotFound);
end;
if Result.Node.Desc<>ctnProcedureType then begin
TypeContext.Tool.MoveCursorToNodeStart(TypeContext.Node);
TypeContext.Tool.RaiseException(Format(ctsExpectedAMethodTypeButFound, [
Result.Node.DescAsString]));
Params:=TFindDeclarationParams.Create(CLList);
try
Params.Flags:=[fdfExceptionOnNotFound,fdfSearchInParentNodes];
Result:=TypeContext.Tool.FindBaseTypeOfNode(Params,TypeContext.Node);
if Result.Node=nil then begin
TypeContext.Tool.MoveCursorToNodeStart(TypeContext.Node);
TypeContext.Tool.RaiseException(ctsMethodTypeDefinitionNotFound);
end;
if Result.Node.Desc<>ctnProcedureType then begin
TypeContext.Tool.MoveCursorToNodeStart(TypeContext.Node);
TypeContext.Tool.RaiseException(Format(ctsExpectedAMethodTypeButFound, [
Result.Node.DescAsString]));
end;
finally
Params.Free;
end;
finally
Params.Free;
CLList.Free;
end;
finally
DeactivateGlobalWriteLock;
@ -1124,9 +1130,9 @@ begin
//debugln(['TEventsCodeTool.FindTypeOfPropertyInfo found: ',FindContextToString(AClassContext)]);
// search property
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create(Self, AClassContext.Node);
try
Params.Flags:=[fdfSearchInAncestors];
Params.Flags:=[fdfSearchInAncestors,fdfSearchInHelpers];
if ExceptionOnNotFound then Include(Params.Flags,fdfExceptionOnNotFound);
Params.ContextNode:=AClassContext.Node;
Params.SetIdentifier(Self,PChar(PropName),nil);
@ -1240,7 +1246,7 @@ begin
Params.Flags:=[fdfSearchInParentNodes,
fdfIgnoreCurContextNode]
+(fdfGlobals*Params.Flags)
-[fdfSearchInAncestors];
-[fdfSearchInAncestors,fdfSearchInHelpers];
CurExprType:=GetExpressionTypeOfTypeIdentifier(Params);
{$IFDEF VerboseTypeData}
DebugLn('[TEventsCodeTool.CreateExprListFromMethodTypeData] B ',

108
components/codetools/extractproctool.pas
View File

@ -1117,62 +1117,69 @@ var
i: Integer;
Cache: PWithVarCache;
Params: TFindDeclarationParams;
CLList: THelpersList;
begin
Result:=false;
// check cache
if WithVarCache=nil then
WithVarCache:=TFPList.Create;
i:=WithVarCache.Count-1;
while (i>=0) and (PWithVarCache(WithVarCache[i])^.WithVarNode<>WithVarNode) do
dec(i);
if i>=0 then begin
Cache:=PWithVarCache(WithVarCache[i]);
end else begin
// resolve type of With variable
{$IFDEF CTDEBUG}
debugln(['IdentifierDefinedByWith NEW WithVar']);
{$ENDIF}
New(Cache);
WithVarCache.Add(Cache);
Cache^.WithVarNode:=WithVarNode;
Cache^.WithVarExpr:=CleanExpressionType;
Cache^.VarEndPos:=FindEndOfTerm(WithVarNode.StartPos,false,true);
Params:=TFindDeclarationParams.Create;
try
Params.ContextNode:=WithVarNode;
Params.Flags:=[fdfExceptionOnNotFound,fdfFunctionResult,fdfFindChildren];
Cache^.WithVarExpr:=FindExpressionTypeOfTerm(WithVarNode.StartPos,-1,Params,true);
if (Cache^.WithVarExpr.Desc<>xtContext)
or (Cache^.WithVarExpr.Context.Node=nil)
or (not (Cache^.WithVarExpr.Context.Node.Desc
in (AllClasses+[ctnEnumerationType])))
then begin
MoveCursorToCleanPos(Cache^.WithVarNode.StartPos);
RaiseException(ctsExprTypeMustBeClassOrRecord);
end;
CLList := THelpersList.Create;
try
FindHelpersInContext(WithVarNode, CLList);
// check cache
if WithVarCache=nil then
WithVarCache:=TFPList.Create;
i:=WithVarCache.Count-1;
while (i>=0) and (PWithVarCache(WithVarCache[i])^.WithVarNode<>WithVarNode) do
dec(i);
if i>=0 then begin
Cache:=PWithVarCache(WithVarCache[i]);
end else begin
// resolve type of With variable
{$IFDEF CTDEBUG}
debugln(['IdentifierDefinedByWith WithVarExpr=',ExprTypeToString(Cache^.WithVarExpr)]);
debugln(['IdentifierDefinedByWith NEW WithVar']);
{$ENDIF}
New(Cache);
WithVarCache.Add(Cache);
Cache^.WithVarNode:=WithVarNode;
Cache^.WithVarExpr:=CleanExpressionType;
Cache^.VarEndPos:=FindEndOfTerm(WithVarNode.StartPos,false,true);
Params:=TFindDeclarationParams.Create(CLList);
try
Params.ContextNode:=WithVarNode;
Params.Flags:=[fdfExceptionOnNotFound,fdfFunctionResult,fdfFindChildren];
Cache^.WithVarExpr:=FindExpressionTypeOfTerm(WithVarNode.StartPos,-1,Params,true);
if (Cache^.WithVarExpr.Desc<>xtContext)
or (Cache^.WithVarExpr.Context.Node=nil)
or (not (Cache^.WithVarExpr.Context.Node.Desc
in (AllClasses+[ctnEnumerationType])))
then begin
MoveCursorToCleanPos(Cache^.WithVarNode.StartPos);
RaiseException(ctsExprTypeMustBeClassOrRecord);
end;
{$IFDEF CTDEBUG}
debugln(['IdentifierDefinedByWith WithVarExpr=',ExprTypeToString(Cache^.WithVarExpr)]);
{$ENDIF}
finally
Params.Free;
end;
end;
if CleanPos<=Cache^.VarEndPos then exit;
// search identifier in with var context
Params:=TFindDeclarationParams.Create(CLList);
try
Params.SetIdentifier(Self,@Src[CleanPos],nil);
Params.Flags:=[fdfSearchInAncestors,fdfSearchInHelpers];
Params.ContextNode:=Cache^.WithVarExpr.Context.Node;
Result:=Cache^.WithVarExpr.Context.Tool.FindIdentifierInContext(Params);
{$IFDEF CTDEBUG}
debugln(['IdentifierDefinedByWith Identifier=',GetIdentifier(@Src[CleanPos]),' FoundInWith=',Result,' WithVar="',dbgstr(Src,WithVarNode.StartPos,10),'"']);
{$ENDIF}
finally
Params.Free;
end;
end;
if CleanPos<=Cache^.VarEndPos then exit;
// search identifier in with var context
Params:=TFindDeclarationParams.Create;
try
Params.SetIdentifier(Self,@Src[CleanPos],nil);
Params.Flags:=[fdfSearchInAncestors];
Params.ContextNode:=Cache^.WithVarExpr.Context.Node;
Result:=Cache^.WithVarExpr.Context.Tool.FindIdentifierInContext(Params);
{$IFDEF CTDEBUG}
debugln(['IdentifierDefinedByWith Identifier=',GetIdentifier(@Src[CleanPos]),' FoundInWith=',Result,' WithVar="',dbgstr(Src,WithVarNode.StartPos,10),'"']);
{$ENDIF}
finally
Params.Free;
CLList.Free;
end;
end;
@ -1765,12 +1772,13 @@ var
IsInSelection:=(VarStartPos>=BlockStartPos) and (VarStartPos<BlockEndPos);
IsAfterSelection:=(VarStartPos>=BlockEndPos);
MoveCursorToCleanPos(VarStartPos);
Params:=TFindDeclarationParams.Create;
VarNode:=FindDeepestNodeAtPos(VarStartPos,true);
Params:=TFindDeclarationParams.Create(Self, VarNode);
try
// find declaration
Params.ContextNode:=FindDeepestNodeAtPos(VarStartPos,true);
Params.ContextNode:=VarNode;
Params.Flags:=[fdfSearchInParentNodes,fdfExceptionOnNotFound,
fdfTopLvlResolving,fdfSearchInAncestors];
fdfTopLvlResolving,fdfSearchInAncestors,fdfSearchInHelpers];
Params.SetIdentifier(Self,@Src[VarStartPos],@CheckSrcIdentifier);
{$IFDEF CTDebug}
DebugLn('AddVariableAtCursor Searching ',GetIdentifier(Params.Identifier));

998
components/codetools/finddeclarationtool.pas
View File

File diff suppressed because it is too large Load Diff

67
components/codetools/identcompletiontool.pas
View File

@ -388,7 +388,7 @@ type
): TCodeXYPosition;
procedure FindCollectionContext(Params: TFindDeclarationParams;
IdentStartPos: integer; CursorNode: TCodeTreeNode;
out GatherContext: TFindContext; out ContextExprStartPos: LongInt;
out ExprType: TExpressionType; out ContextExprStartPos: LongInt;
out StartInSubContext: Boolean);
function CollectAllContexts(Params: TFindDeclarationParams;
const FoundContext: TFindContext): TIdentifierFoundResult;
@ -1692,6 +1692,7 @@ begin
case Node.Desc of
ctnClass,ctnObject,ctnRecordType,ctnObjCCategory,ctnObjCClass,
ctnClassHelper, ctnRecordHelper, ctnTypeHelper,
ctnClassPrivate,ctnClassProtected,ctnClassPublic,ctnClassPublished:
begin
Add('public');
@ -1949,7 +1950,7 @@ end;
procedure TIdentCompletionTool.FindCollectionContext(
Params: TFindDeclarationParams; IdentStartPos: integer;
CursorNode: TCodeTreeNode;
out GatherContext: TFindContext;
out ExprType: TExpressionType;
out ContextExprStartPos: LongInt;
out StartInSubContext: Boolean);
@ -1979,10 +1980,11 @@ procedure TIdentCompletionTool.FindCollectionContext(
end;
var
ExprType: TExpressionType;
IgnoreCurContext: Boolean;
GatherContext: TFindContext;
begin
GatherContext:=CreateFindContext(Self,CursorNode);
ExprType := CleanExpressionType;
IgnoreCurContext:=false;
//DebugLn(['TIdentCompletionTool.FindCollectionContext IdentStartPos=',dbgstr(copy(Src,IdentStartPos,20)),' ',CursorNode.DescAsString]);
@ -2010,17 +2012,18 @@ begin
Params.ContextNode:=CursorNode;
Params.SetIdentifier(Self,nil,nil);
Params.Flags:=[fdfExceptionOnNotFound,
fdfSearchInParentNodes,fdfSearchInAncestors];
fdfSearchInParentNodes,fdfSearchInAncestors,fdfSearchInHelpers,fdfTypeType];
if IgnoreCurContext then
Params.Flags:=Params.Flags+[fdfIgnoreCurContextNode];
ExprType:=FindExpressionTypeOfTerm(ContextExprStartPos,IdentStartPos,
Params,false);
if (ExprType.Desc=xtContext) then begin
if (ExprType.Desc in xtAllIdentTypes) then begin
GatherContext:=ExprType.Context;
debugln(['TIdentCompletionTool.FindCollectionContext ',ExprTypeToString(ExprType)]);
StartInSubContext:=true;
end;
end;
ExprType.Context := GatherContext;
end;
function TIdentCompletionTool.CollectAllContexts(
@ -2470,6 +2473,7 @@ var
CursorContext: TFindContext;
IdentStartXY: TCodeXYPosition;
InFrontOfDirective: Boolean;
ExprType: TExpressionType;
procedure CheckProcedureDeclarationContext;
var
@ -2515,7 +2519,7 @@ begin
Result:=false;
ActivateGlobalWriteLock;
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create;//FindHelpersInContext called later
try
InitCollectIdentifiers(CursorPos,IdentifierList);
IdentStartXY:=FindIdentifierStartPos(CursorPos);
@ -2523,6 +2527,8 @@ begin
ParseSourceTillCollectionStart(IdentStartXY,CleanCursorPos,CursorNode,
IdentStartPos,IdentEndPos);
Params.ContextNode:=CursorNode;
FindHelpersInContext(Params);
if CleanCursorPos=0 then ;
if IdentStartPos>0 then begin
MoveCursorToCleanPos(IdentStartPos);
@ -2553,8 +2559,9 @@ begin
GatherSourceNames(GatherContext);
end else begin
FindCollectionContext(Params,IdentStartPos,CursorNode,
GatherContext,ContextExprStartPos,StartInSubContext);
ExprType,ContextExprStartPos,StartInSubContext);
GatherContext := ExprType.Context;
// find class and ancestors if existing (needed for protected identifiers)
if GatherContext.Tool = Self then
FindContextClassAndAncestors(IdentStartXY, FICTClassAndAncestors);
@ -2574,7 +2581,7 @@ begin
// gather all identifiers in context
Params.ContextNode:=GatherContext.Node;
Params.SetIdentifier(Self,nil,@CollectAllIdentifiers);
Params.Flags:=[fdfSearchInAncestors,fdfCollect,fdfFindVariable];
Params.Flags:=[fdfSearchInAncestors,fdfCollect,fdfFindVariable,fdfSearchInHelpers];
if (Params.ContextNode.Desc=ctnInterface) and StartInSubContext then
Include(Params.Flags,fdfIgnoreUsedUnits);
if not StartInSubContext then
@ -2588,6 +2595,15 @@ begin
if GatherContext.Node.Desc=ctnIdentifier then
Params.Flags:=Params.Flags+[fdfIgnoreCurContextNode];
GatherContext.Tool.FindIdentifierInContext(Params);
end else
if ExprType.Desc in xtAllIdentPredefinedTypes then
begin
// gather all identifiers in cursor context for basic types (strings etc.)
Params.ContextNode:=CursorNode;
Params.SetIdentifier(Self,nil,@CollectAllIdentifiers);
Params.Flags:=[fdfSearchInAncestors,fdfCollect,fdfFindVariable,fdfSearchInHelpers];
CurrentIdentifierList.Context:=GatherContext;
FindIdentifierInBasicTypeHelpers(ExprType.Desc, Params);
end;
// check for incomplete context
@ -2823,9 +2839,9 @@ var
var
VarNameAtom, ProcNameAtom: TAtomPosition;
ParameterIndex: integer;
GatherContext: TFindContext;
ContextExprStartPos: LongInt;
StartInSubContext: Boolean;
ExprType: TExpressionType;
begin
Result:=false;
// check if in a begin..end block
@ -2865,24 +2881,37 @@ var
CurrentIdentifierContexts.EndPos:=SrcLen+1;
FindCollectionContext(Params,ProcNameAtom.StartPos,CursorNode,
GatherContext,ContextExprStartPos,StartInSubContext);
ExprType,ContextExprStartPos,StartInSubContext);
if ContextExprStartPos=0 then ;
{$IFDEF VerboseCodeContext}
DebugLn(['CheckContextIsParameter StartInSubContext=',StartInSubContext,' ',GatherContext.Node.DescAsString,' "',copy(GatherContext.Tool.Src,GatherContext.Node.StartPos-20,25),'"']);
DebugLn(['CheckContextIsParameter StartInSubContext=',StartInSubContext,' ',ExprType.Context.Node.DescAsString,' "',copy(ExprType.Context.Tool.Src,GatherContext.Node.StartPos-20,25),'"']);
{$ENDIF}
// gather declarations of all parameter lists
Params.ContextNode:=GatherContext.Node;
if (ExprType.Context.Node = nil) or (ExprType.Context.Tool = nil) then
begin
if ExprType.Desc in xtAllIdentPredefinedTypes then
begin
ExprType.Context.Node := CursorNode;
ExprType.Context.Tool := Self;
end else
Exit;
end;
Params.ContextNode:=ExprType.Context.Node;
Params.SetIdentifier(Self,@Src[ProcNameAtom.StartPos],@CollectAllContexts);
Params.Flags:=[fdfSearchInAncestors,fdfCollect,fdfFindVariable];
Params.Flags:=[fdfSearchInAncestors,fdfCollect,fdfFindVariable,fdfSearchInHelpers];
if not StartInSubContext then
Include(Params.Flags,fdfSearchInParentNodes);
CurrentIdentifierList.Context:=GatherContext;
CurrentIdentifierList.Context:=ExprType.Context;
{$IFDEF VerboseCodeContext}
DebugLn('CheckContextIsParameter searching procedures, properties and variables ...');
{$ENDIF}
GatherContext.Tool.FindIdentifierInContext(Params);
if ExprType.Desc in xtAllIdentPredefinedTypes then
ExprType.Context.Tool.FindIdentifierInBasicTypeHelpers(ExprType.Desc, Params)
else
ExprType.Context.Tool.FindIdentifierInContext(Params);
{$IFDEF VerboseCodeContext}
DebugLn('CheckContextIsParameter END');
{$ENDIF}
@ -2900,11 +2929,13 @@ begin
CurrentIdentifierContexts:=CodeContexts;
ActivateGlobalWriteLock;
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create;//FindHelpersInContext called later
try
InitCollectIdentifiers(CursorPos,IdentifierList);
ParseSourceTillCollectionStart(CursorPos,CleanCursorPos,CursorNode,
IdentStartPos,IdentEndPos);
Params.ContextNode:=CursorNode;
FindHelpersInContext(Params);
if IdentStartPos=0 then ;
if IdentEndPos=0 then ;
@ -3212,7 +3243,7 @@ begin
EndPos:=CleanCursorPos;
//DebugLn(['TIdentCompletionTool.GetValuesOfCaseVariable Expr=',dbgstr(copy(Src,CaseAtom.EndPos,EndPos-CaseAtom.EndPos))]);
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create(Self, CursorNode);
Params.ContextNode:=CursorNode;
Params.Flags:=fdfDefaultForExpressions+[fdfFunctionResult];
ExprType:=FindExpressionTypeOfTerm(CaseAtom.EndPos,EndPos,Params,true);
@ -3598,7 +3629,7 @@ begin
ANode:=Node;
if (ANode<>nil) and (Tool<>nil) then begin
Tool.ActivateGlobalWriteLock;
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create(Tool, ANode);
try
if ANode.HasParentOfType(ctnGenericType) then exit;
BaseExprType.Context:=Tool.FindBaseTypeOfNode(Params,ANode);

4
components/codetools/languages/codetoolsstrconsts.ca.po
View File

@ -431,6 +431,10 @@ msgstr "directori d'interfície del gtk2"
msgid "HasError"
msgstr ""
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr "Directori de l'IDE"

4
components/codetools/languages/codetoolsstrconsts.cs.po
View File

@ -432,6 +432,10 @@ msgstr "adresář rozhraní gtk2"
msgid "HasError"
msgstr "HasError"
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr "Adresář IDE"

4
components/codetools/languages/codetoolsstrconsts.de.po
View File

@ -432,6 +432,10 @@ msgstr "Gtk-Interface-Verzeichnis"
msgid "HasError"
msgstr ""
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr "IDE-Verzeichnis"

4
components/codetools/languages/codetoolsstrconsts.es.po
View File

@ -427,6 +427,10 @@ msgstr "directorio de la interfase gtk2"
msgid "HasError"
msgstr "EsError"
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr "Directorio del IDE"

6
components/codetools/languages/codetoolsstrconsts.fi.po
View File

@ -422,6 +422,10 @@ msgstr "gtk2 rajapinnan hakemisto"
msgid "HasError"
msgstr ""
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr "IDE hakemisto"
@ -691,6 +695,7 @@ msgid "operand expected, but %s found"
msgstr "odotettiin operandia, mutta saatiin %s"
#: codetoolsstrconsts.ctsoperatorexpectedbutatomfound
msgctxt "codetoolsstrconsts.ctsoperatorexpectedbutatomfound"
msgid "operator expected, but %s found"
msgstr "odotettiin operaattoria, mutta saatiin %s"
@ -703,6 +708,7 @@ msgid "operator expected but %s found"
msgstr "odotettiin operaattoria, mutta saatiin %s"
#: codetoolsstrconsts.ctsoperatorexpectedbutfound2
msgctxt "codetoolsstrconsts.ctsoperatorexpectedbutfound2"
msgid "operator expected, but %s found"
msgstr "odotettiin operaattoria, mutta saatiin %s"

5
components/codetools/languages/codetoolsstrconsts.fr.po
View File

@ -429,6 +429,10 @@ msgstr "répertoire d'interface pour gtk2"
msgid "HasError"
msgstr "Contient une erreur"
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr "Répertoire de l'EDI"
@ -954,3 +958,4 @@ msgstr "Répertoire des éléments graphiques (\"widgets\")"
#: codetoolsstrconsts.ctswordnotfound
msgid "\"%s\" not found"
msgstr "\"%s\" non trouvé"

4
components/codetools/languages/codetoolsstrconsts.he.po
View File

@ -431,6 +431,10 @@ msgstr "תיקיית הממשק של gtk2"
msgid "HasError"
msgstr "יש בו שגיאה"
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr "תיקיית ה IDE "

5
components/codetools/languages/codetoolsstrconsts.hu.po
View File

@ -429,6 +429,10 @@ msgstr "gtk2 felület könyvtára"
msgid "HasError"
msgstr "Hibás"
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr "IDE könyvtára"
@ -954,3 +958,4 @@ msgstr "Vezérlőkészlet könyvtára"
#: codetoolsstrconsts.ctswordnotfound
msgid "\"%s\" not found"
msgstr "\"%s\" nem található"

4
components/codetools/languages/codetoolsstrconsts.id.po
View File

@ -432,6 +432,10 @@ msgstr "Direktori interface gtk2"
msgid "HasError"
msgstr ""
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr "Direktori IDE"

4
components/codetools/languages/codetoolsstrconsts.it.po
View File

@ -427,6 +427,10 @@ msgstr "gtk2 directory di interfaccia"
msgid "HasError"
msgstr "HasError"
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr "Cartella dell'IDE"

4
components/codetools/languages/codetoolsstrconsts.lt.po
View File

@ -432,6 +432,10 @@ msgstr "gtk2 interfeiso aplankas"
msgid "HasError"
msgstr "TuriKlaida"
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr "IKA aplankas"

4
components/codetools/languages/codetoolsstrconsts.nl.po
View File

@ -431,6 +431,10 @@ msgstr ""
msgid "HasError"
msgstr ""
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr ""

4
components/codetools/languages/codetoolsstrconsts.pl.po
View File

@ -435,6 +435,10 @@ msgstr "katalog interfejsu gtk2"
msgid "HasError"
msgstr ""
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr ""

4
components/codetools/languages/codetoolsstrconsts.po
View File

@ -422,6 +422,10 @@ msgstr ""
msgid "HasError"
msgstr ""
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr ""

4
components/codetools/languages/codetoolsstrconsts.pt_BR.po
View File

@ -431,6 +431,10 @@ msgstr "diretório de interface gtk2"
msgid "HasError"
msgstr "Há Erros"
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr "Diretório do IDE"

4
components/codetools/languages/codetoolsstrconsts.ru.po
View File

@ -429,6 +429,10 @@ msgstr "каталог интерфейса gtk2"
msgid "HasError"
msgstr "Ошибка"
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr "Каталог IDE"

4
components/codetools/languages/codetoolsstrconsts.sk.po
View File

@ -430,6 +430,10 @@ msgstr ""
msgid "HasError"
msgstr ""
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr ""

4
components/codetools/languages/codetoolsstrconsts.uk.po
View File

@ -432,6 +432,10 @@ msgstr "тека інтерфейсу gtk2"
msgid "HasError"
msgstr "HasError"
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr "Тека IDE"

4
components/codetools/languages/codetoolsstrconsts.zh_CN.po
View File

@ -434,6 +434,10 @@ msgstr "gtk2 接口目录"
msgid "HasError"
msgstr ""
#: codetoolsstrconsts.ctshelperisnotallowed
msgid "Helper after %s is not allowed"
msgstr ""
#: codetoolsstrconsts.ctsidedirectory
msgid "IDE Directory"
msgstr "IDE 目录"

3
components/codetools/methodjumptool.pas
View File

@ -357,6 +357,7 @@ begin
// first test if in a class
ClassNode:=CursorNode.GetNodeOfTypes([ctnClass,ctnClassInterface,
ctnDispinterface,ctnObject,ctnRecordType,
ctnClassHelper,ctnRecordHelper,ctnTypeHelper,
ctnObjCClass,ctnObjCCategory,ctnObjCProtocol,
ctnCPPClass]);
if ClassNode<>nil then begin
@ -809,7 +810,7 @@ begin
cmp:=false;
end;
if cmp and (phpIgnoreMethods in Attr) then begin
if (ANode.GetNodeOfTypes([ctnClass,ctnObject,ctnRecordType,
if (ANode.GetNodeOfTypes([ctnClass,ctnObject,ctnRecordType,ctnClassHelper,ctnRecordHelper,ctnTypeHelper,
ctnObjCClass,ctnObjCCategory,ctnCPPClass])<>nil)
or (ExtractClassNameOfProcNode(ANode,true)<>'')
then

75
components/codetools/pascalparsertool.pas
View File

@ -277,6 +277,7 @@ type
function FindSectionNodeAtPos(P: integer): TCodeTreeNode;
function FindScanRangeNode(Range: TLinkScannerRange): TCodeTreeNode;
function FindScanRangeNodeAtPos(P: integer): TCodeTreeNode;
function FindLastNode: TCodeTreeNode;
function NodeHasParentOfType(ANode: TCodeTreeNode;
NodeDesc: TCodeTreeNodeDesc): boolean;
@ -3542,7 +3543,7 @@ begin
SaveRaiseExceptionWithHint;
UndoReadNextAtom;
EndChildNode;
end else if (CurNode.Desc in [ctnProgram,ctnLibrary,ctnImplementation]) then
end else if (CurNode<>nil) and (CurNode.Desc in [ctnProgram,ctnLibrary,ctnImplementation]) then
begin
ReadNextAtom;
if (CurPos.Flag<>cafPoint) then
@ -4162,8 +4163,6 @@ begin
end;
end else begin
// forward definition
if IntfDesc=ctnTypeHelper then
SaveRaiseException('forward defined type helpers are not allowed');
CurNode.SubDesc:=CurNode.SubDesc+ctnsForwardDeclaration;
end;
if CurPos.Flag=cafEND then begin
@ -4221,6 +4220,7 @@ var
ClassDesc: TCodeTreeNodeDesc;
ClassNode: TCodeTreeNode;
IsHelper: Boolean;
HelperForNode: TCodeTreeNode;
begin
//debugln(['TPascalParserTool.KeyWordFuncTypeClass ',GetAtom,' ',CleanPosToStr(CurPos.StartPos)]);
// class or 'class of' start found
@ -4236,10 +4236,12 @@ begin
ClassDesc:=ctnObjCCategory
else if UpAtomIs('CPPCLASS') then
ClassDesc:=ctnCPPClass
else if UpAtomIs('TYPE') then
ClassDesc:=ctnTypeType
else
SaveRaiseStringExpectedButAtomFound('class');
ContextDesc:=CurNode.Desc;
if ClassDesc<>ctnRecordType then begin
if not(ClassDesc in [ctnRecordType, ctnTypeType]) then begin
if not (ContextDesc in [ctnTypeDefinition,ctnGenericType])
then
SaveRaiseExceptionFmt(ctsAnonymDefinitionsAreNotAllowed,[GetAtom]);
@ -4311,10 +4313,14 @@ begin
end;
end else if UpAtomIs('HELPER') then begin
IsHelper:=true;
CreateChildNode;
CurNode.Desc:=ctnClassHelper;
CurNode.EndPos:=CurPos.EndPos;
EndChildNode;
case ClassDesc of
ctnClass: CurNode.Desc:=ctnClassHelper;
ctnRecordType: CurNode.Desc:=ctnRecordHelper;
ctnTypeType: CurNode.Desc:=ctnTypeHelper;
else
SaveRaiseExceptionFmt(ctsHelperIsNotAllowed,[GetAtom]);
end;
ClassDesc:=CurNode.Desc;
ReadNextAtom;
end;
end;
@ -4328,14 +4334,21 @@ begin
if not UpAtomIs('FOR') then
SaveRaiseStringExpectedButAtomFound('for');
CreateChildNode;
CurNode.Desc:=ctnClassHelperFor;
CurNode.Desc:=ctnHelperFor;
HelperForNode:=CurNode;
CreateChildNode;
CurNode.Desc:=ctnIdentifier;
repeat
ReadNextAtom;
if CurNode.StartPos = HelperForNode.StartPos then
CurNode.StartPos:=CurPos.StartPos;
AtomIsIdentifierSaveE;
CurNode.EndPos:=CurPos.EndPos;
HelperForNode.EndPos:=CurPos.EndPos;
ReadNextAtom;
until CurPos.Flag<>cafPoint;
EndChildNode;
EndChildNode;
end;
end;
if CurPos.Flag=cafSemicolon then begin
@ -4614,38 +4627,23 @@ end;
function TPascalParserTool.KeyWordFuncTypeType: boolean;
// 'type identifier'
var
StartPos: Integer;
begin
if not LastAtomIs(0,'=') then
SaveRaiseStringExpectedButAtomFound(ctsIdentifier);
CreateChildNode;
CurNode.Desc:=ctnTypeType;
StartPos := CurPos.StartPos;
ReadNextAtom;
if UpAtomIs('HELPER') and (cmsTypeHelpers in Scanner.CompilerModeSwitches) then
if UpAtomIs('HELPER') then begin
UndoReadNextAtom;
Result := KeyWordFuncTypeClass;
end else
begin
// type helper(inheritance) for typename
CurNode.Desc:=ctnTypeHelper;
// read inheritance
ReadNextAtom;
if (CurPos.Flag=cafRoundBracketOpen) then begin
// read inheritage brackets
ReadClassInheritance(true);
ReadNextAtom;
end;
// read 'FOR'
if not UpAtomIs('FOR') then
SaveRaiseStringExpectedButAtomFound('FOR');
// read helperfor
ReadNextAtom;
AtomIsIdentifierE;
CreateChildNode;
CurNode.Desc:=ctnClassHelperFor;
EndChildNode;
// read props and procs
ReadClassInterfaceContent;
end else begin
CurNode.StartPos:=StartPos;
CurNode.Desc:=ctnTypeType;
Result:=ParseType(CurPos.StartPos);
CurNode.EndPos:=CurPos.EndPos;
EndChildNode;
Result:=true;
end;
end;
@ -5740,7 +5738,7 @@ begin
exit;
end;
try
IsMethod:=ProcNode.Parent.Desc in (AllClasses+AllClassSections);
IsMethod:=(ProcNode.Parent<>nil) and (ProcNode.Parent.Desc in (AllClasses+AllClassSections));
MoveCursorToNodeStart(ProcNode);
ReadNextAtom;
if UpAtomIs('CLASS') then
@ -5868,6 +5866,13 @@ begin
Result:=FindRootNode(ctnImplementation);
end;
function TPascalParserTool.FindLastNode: TCodeTreeNode;
begin
Result := FindRootNode(ctnEndPoint);
if Result=nil then
Result := Tree.GetLastNode;
end;
function TPascalParserTool.FindImplementationUsesNode: TCodeTreeNode;
begin
Result:=Tree.Root;

11
components/codetools/pascalreadertool.pas
View File

@ -199,6 +199,7 @@ type
function ClassSectionNodeStartsWithWord(ANode: TCodeTreeNode): boolean;
function IsClassNode(Node: TCodeTreeNode): boolean; // class, not object
function FindInheritanceNode(ClassNode: TCodeTreeNode): TCodeTreeNode;
function FindHelperForNode(HelperNode: TCodeTreeNode): TCodeTreeNode;
// records
function ExtractRecordCaseType(RecordCaseNode: TCodeTreeNode): string;
@ -2797,6 +2798,16 @@ begin
end;
end;
function TPascalReaderTool.FindHelperForNode(HelperNode: TCodeTreeNode
): TCodeTreeNode;
begin
Result:=HelperNode.FirstChild;
while (Result<>nil) and (Result.Desc = ctnClassInheritance) do
Result:=Result.NextBrother;
if (Result<>nil) and (Result.Desc<>ctnHelperFor) then
Result:=nil;
end;
function TPascalReaderTool.FindTypeOfForwardNode(TypeNode: TCodeTreeNode
): TCodeTreeNode;

1
docs/Contributors.txt
View File

@ -155,6 +155,7 @@ Mike Sapsard
Mike Thompson
Nikolay Ermolov
Olivier Guilbaud
Ondrej Pokorny
Patrick Chevalley
Paul Ishenin
Paul Michell

9
ide/codebrowser.pas
View File

@ -1952,7 +1952,8 @@ begin
case CTNode.FirstChild.Desc of
ctnClass,ctnClassInterface,ctnObject,
ctnObjCClass,ctnObjCCategory,ctnObjCProtocol,
ctnCPPClass:
ctnCPPClass,
ctnClassHelper,ctnRecordHelper,ctnTypeHelper:
begin
case CTNode.FirstChild.Desc of
ctnClassInterface:
@ -1967,6 +1968,12 @@ begin
Description:=Description+' = objcprotocol';
ctnCPPClass:
Description:=Description+' = cppclass';
ctnClassHelper:
Description:=Description+' = class helper';
ctnRecordHelper:
Description:=Description+' = record helper';
ctnTypeHelper:
Description:=Description+' = type helper';
else
Description:=Description+' = class';
end;

2
ide/codecontextform.pas
View File

@ -378,7 +378,7 @@ procedure TCodeContextFrm.CreateHints(const CodeContexts: TCodeContextInfo);
ExprNode: TCodeTreeNode;
begin
Result:=false;
Params:=TFindDeclarationParams.Create;
Params:=TFindDeclarationParams.Create(Tool, Node);
try
try
Expr:=Tool.ConvertNodeToExpressionType(Node,Params);

59
ide/codeexplorer.pas
View File

@ -179,6 +179,9 @@ type
fSortCodeTool: TCodeTool;
FUpdateCount: integer;
ImgIDClass: Integer;
ImgIDClassInterface: Integer;
ImgIDRecord: Integer;
ImgIDHelper: Integer;
ImgIDConst: Integer;
ImgIDSection: Integer;
ImgIDDefault: integer;
@ -489,6 +492,9 @@ begin
ImgIDVariable := Imagelist1.AddResourceName(HInstance, 'ce_variable');
ImgIDConst := Imagelist1.AddResourceName(HInstance, 'ce_const');
ImgIDClass := Imagelist1.AddResourceName(HInstance, 'ce_class');
ImgIDClassInterface := Imagelist1.AddResourceName(HInstance, 'ce_classinterface');
ImgIDHelper := Imagelist1.AddResourceName(HInstance, 'ce_helper');
ImgIDRecord := Imagelist1.AddResourceName(HInstance, 'ce_record');
ImgIDProcedure := Imagelist1.AddResourceName(HInstance, 'ce_procedure');
ImgIDFunction := Imagelist1.AddResourceName(HInstance, 'ce_function');
ImgIDProperty := Imagelist1.AddResourceName(HInstance, 'ce_property');
@ -702,6 +708,8 @@ end;
function TCodeExplorerView.GetCodeNodeDescription(ACodeTool: TCodeTool;
CodeNode: TCodeTreeNode): string;
var
ClassIdentNode, HelperForNode, InhNode: TCodeTreeNode;
begin
Result:='?';
@ -726,9 +734,27 @@ begin
ctnResStrSection:
Result:='Resourcestring';
ctnTypeDefinition,ctnVarDefinition,ctnConstDefinition,ctnUseUnit:
ctnVarDefinition,ctnConstDefinition,ctnUseUnit:
Result:=ACodeTool.ExtractIdentifier(CodeNode.StartPos);
ctnTypeDefinition:
begin
Result:=ACodeTool.ExtractIdentifier(CodeNode.StartPos);
ClassIdentNode := CodeNode.FirstChild;
if Assigned(ClassIdentNode) then
begin
if ClassIdentNode.Desc in [ctnClassHelper, ctnRecordHelper, ctnTypeHelper] then
HelperForNode := ACodeTool.FindHelperForNode(ClassIdentNode)
else
HelperForNode := nil;
InhNode:=ACodeTool.FindInheritanceNode(ClassIdentNode);
if InhNode<>nil then
Result:=Result+ACodeTool.ExtractNode(InhNode,[]);
if HelperForNode<>nil then
Result:=Result+' '+ACodeTool.ExtractNode(HelperForNode,[]);
end;
end;
ctnGenericType:
Result:=ACodeTool.ExtractDefinitionName(CodeNode);
@ -809,9 +835,19 @@ begin
ctnTypeSection: Result:=ImgIDSection;
ctnTypeDefinition:
begin
if (CodeNode.FirstChild <> nil)
and (CodeNode.FirstChild.Desc in AllClasses) then
Result := ImgIDClass
if (CodeNode.FirstChild <> nil) then
case CodeNode.FirstChild.Desc of
ctnClassInterface,ctnDispinterface,ctnObjCProtocol:
Result := ImgIDClassInterface;
ctnClass,ctnObjCClass,ctnObjCCategory,ctnCPPClass:
Result := ImgIDClass;
ctnObject,ctnRecordType:
Result := ImgIDRecord;
ctnClassHelper,ctnRecordHelper,ctnTypeHelper:
Result := ImgIDHelper;
else
Result := ImgIDType;
end
else
Result := ImgIDType;
end;
@ -819,9 +855,14 @@ begin
ctnVarDefinition: Result:=ImgIDVariable;
ctnConstSection,ctnResStrSection: Result:=ImgIDSection;
ctnConstDefinition: Result:=ImgIDConst;
ctnClass,ctnClassInterface,ctnObject,
ctnObjCClass,ctnObjCProtocol,ctnObjCCategory,ctnCPPClass:
ctnClassInterface,ctnDispinterface,ctnObjCProtocol:
Result := ImgIDClassInterface;
ctnClass,ctnObject,
ctnObjCClass,ctnObjCCategory,ctnCPPClass:
Result:=ImgIDClass;
ctnRecordType: Result:=ImgIDRecord;
ctnClassHelper,ctnRecordHelper,ctnTypeHelper:
Result:=ImgIDHelper;
ctnProcedure: if Tool.NodeIsFunction(CodeNode) then
Result:=ImgIDFunction
else
@ -905,8 +946,10 @@ begin
if CodeNode.Desc=ctnEnumerationType then
ShowNode:=false;
// don't show special nodes
if CodeNode.Desc in [ctnEndPoint] then
// don't show end node and class modification nodes
if CodeNode.Desc in [ctnEndPoint,ctnClassInheritance,ctnHelperFor,
ctnClassAbstract,ctnClassExternal,ctnClassSealed]
then
ShowNode:=false;
// don't show class visibility section nodes

86
ide/codehelp.pas
View File

@ -310,12 +310,18 @@ type
XYPos: TCodeXYPosition; Options: TCodeHelpHintOptions;
out BaseURL, HTMLHint: string;
out CacheWasUsed: boolean): TCodeHelpParseResult;
function GetHTMLHintForExpr(CTExprType: TExpressionType;
XYPos: TCodeXYPosition; Options: TCodeHelpHintOptions;
out BaseURL, HTMLHint: string;
out CacheWasUsed: boolean): TCodeHelpParseResult;
function GetHTMLHintForUnit(AUnitName, InFilename: string; BaseDir: string;
Options: TCodeHelpHintOptions;
out BaseURL, HTMLHint: string;
out CacheWasUsed: boolean): TCodeHelpParseResult;
function GetHTMLDeclarationHeader(Tool: TFindDeclarationTool;
Node: TCodeTreeNode; XYPos: TCodeXYPosition): string;
function GetHTMLDeclarationHeader(Tool: TFindDeclarationTool;
Node: TCodeTreeNode; Desc: TExpressionTypeDesc; XYPos: TCodeXYPosition): string;
function GetPasDocCommentsAsHTML(Tool: TFindDeclarationTool; Node: TCodeTreeNode): string;
function GetFPDocNodeAsHTML(FPDocFile: TLazFPDocFile; DOMNode: TDOMNode): string;
function TextToHTML(Txt: string): string;
@ -2363,10 +2369,9 @@ function TCodeHelpManager.GetHTMLHint(Code: TCodeBuffer; X, Y: integer;
out CacheWasUsed: boolean): TCodeHelpParseResult;
var
CursorPos: TCodeXYPosition;
CTTool: TFindDeclarationTool;
CTNode: TCodeTreeNode;
XYPos: TCodeXYPosition;
TopLine: integer;
CTExprType: TExpressionType;
begin
Result:=chprFailed;
BaseURL:='lazdoc://';
@ -2381,17 +2386,18 @@ begin
try
// find declaration
if not CodeToolBoss.CurCodeTool.FindDeclaration(CursorPos,
DefaultFindSmartHintFlags+[fsfSearchSourceName],CTTool,CTNode,XYPos,TopLine)
DefaultFindSmartHintFlags+[fsfSearchSourceName],CTExprType,XYPos,TopLine)
then
exit;
if (CTNode=nil) then begin
if (CTExprType.Desc=xtContext) and (CTExprType.Context.Node=nil) then begin
// codetools found a source file, not a declararion
debugln(['TCodeHelpManager.GetHTMLHint not a declaration']);
exit;
end;
Result:=GetHTMLHintForNode(CTTool,CTNode,XYPos,Options,BaseURL,HTMLHint,CacheWasUsed);
Result:=GetHTMLHintForExpr(CTExprType,XYPos,Options,BaseURL,HTMLHint,CacheWasUsed);
// Property details are like "published property TType.PropName:Integer"
PropDetails:=CTTool.GetSmartHint(CTNode,XYPos,false);
if (CTExprType.Desc=xtContext) and (CTExprType.Context.Tool<>nil) then
PropDetails:=CTExprType.Context.Tool.GetSmartHint(CTExprType.Context.Node,XYPos,false);
except
on E: ECodeToolError do begin
//debugln(['TCodeHelpManager.GetHTMLHint ECodeToolError: ',E.Message]);
@ -2403,9 +2409,9 @@ begin
end;
end;
function TCodeHelpManager.GetHTMLHintForNode(CTTool: TFindDeclarationTool;
CTNode: TCodeTreeNode; XYPos: TCodeXYPosition; Options: TCodeHelpHintOptions;
out BaseURL, HTMLHint: string; out CacheWasUsed: boolean): TCodeHelpParseResult;
function TCodeHelpManager.GetHTMLHintForExpr(CTExprType: TExpressionType;
XYPos: TCodeXYPosition; Options: TCodeHelpHintOptions; out BaseURL,
HTMLHint: string; out CacheWasUsed: boolean): TCodeHelpParseResult;
var
aTopLine: integer;
ListOfPCodeXYPosition: TFPList;
@ -2423,11 +2429,22 @@ var
n: Integer;
s: String;
Cmd: TKeyCommandRelation;
CTTool: TFindDeclarationTool;
CTNode: TCodeTreeNode;
begin
Result:=chprFailed;
BaseURL:='lazdoc://';
HTMLHint:='';
CacheWasUsed:=true;
AnOwner := nil;
if (CTExprType.Desc in xtAllPredefinedTypes) then
CTExprType.Context.Tool := CodeToolBoss.CurCodeTool.FindCodeToolForUsedUnit('system','',false);
CTTool := CTExprType.Context.Tool;
CTNode := CTExprType.Context.Node;
if CTTool=nil then
Exit(chprFailed);
ListOfPCodeXYPosition:=nil;
Complete:=not (chhoSmallStep in Options);
@ -2435,10 +2452,15 @@ begin
try
try
if chhoDeclarationHeader in Options then
HTMLHint:=HTMLHint+GetHTMLDeclarationHeader(CTTool,CTNode,XYPos);
HTMLHint:=HTMLHint+GetHTMLDeclarationHeader(CTTool,CTNode,CTExprType.Desc,XYPos);
for n:=1 to 30 do begin
ElementName:=CodeNodeToElementName(CTTool,CTNode);
if (CTExprType.Desc=xtContext) and (CTNode<>nil) then
ElementName:=CodeNodeToElementName(CTTool,CTNode)
else if (CTExprType.Desc in xtAllPredefinedTypes) then
ElementName:=ExpressionTypeDescNames[CTExprType.Desc]
else
break;
//debugln(['TCodeHelpManager.GetHTMLHintForNode ElementName=',ElementName]);
i:=ElementNames.Count-1;
while (i>=0) do begin
@ -2493,9 +2515,10 @@ begin
end;
// find inherited node
if (CTNode.Desc=ctnProperty)
or ((CTNode.Desc in [ctnProcedure,ctnProcedureHead])
and (CTTool.ProcNodeHasSpecifier(CTNode,psOVERRIDE)))
if (CTNode<>nil) and (
(CTNode.Desc=ctnProperty) or
((CTNode.Desc in [ctnProcedure,ctnProcedureHead])
and (CTTool.ProcNodeHasSpecifier(CTNode,psOVERRIDE))))
then begin
{$ifdef VerboseCodeHelp}
debugln(['TCodeHelpManager.GetHTMLHintForNode: searching for inherited of ',CTNode.DescAsString,' ',dbgs(XYPos)]);
@ -2560,6 +2583,19 @@ begin
{$endif}
end;
function TCodeHelpManager.GetHTMLHintForNode(CTTool: TFindDeclarationTool;
CTNode: TCodeTreeNode; XYPos: TCodeXYPosition; Options: TCodeHelpHintOptions;
out BaseURL, HTMLHint: string; out CacheWasUsed: boolean
): TCodeHelpParseResult;
var
ExprType: TExpressionType;
begin
ExprType.Desc:=xtContext;
ExprType.Context.Tool:=CTTool;
ExprType.Context.Node:=CTNode;
Result := GetHTMLHintForExpr(ExprType, XYPos, Options, BaseURL, HTMLHint, CacheWasUsed);
end;
function TCodeHelpManager.GetHTMLHintForUnit(AUnitName, InFilename: string;
BaseDir: string; Options: TCodeHelpHintOptions; out BaseURL,
HTMLHint: string; out CacheWasUsed: boolean): TCodeHelpParseResult;
@ -2615,23 +2651,37 @@ begin
end;
function TCodeHelpManager.GetHTMLDeclarationHeader(Tool: TFindDeclarationTool;
Node: TCodeTreeNode; XYPos: TCodeXYPosition): string;
Node: TCodeTreeNode; Desc: TExpressionTypeDesc; XYPos: TCodeXYPosition
): string;
var
CTHint: String;
begin
Result:='<div class="header">';
// add declaration
CTHint:=Tool.GetSmartHint(Node,XYPos,false);
if Desc=xtContext then
CTHint:=Tool.GetSmartHint(Node,XYPos,false)
else if Desc in xtAllPredefinedTypes then
CTHint:='type '+ExpressionTypeDescNames[Desc];
Result:=Result+' <nobr>'+SourceToFPDocHint(CTHint)+'</nobr>';
// add link to declaration
Result:=Result+'<br>'+LineEnding;
if XYPos.Code=nil then
Tool.CleanPosToCaret(Node.StartPos,XYPos);
if XYPos.Code=nil then begin
if (Node<>nil) then
Tool.CleanPosToCaret(Node.StartPos,XYPos)
else if Desc in xtAllPredefinedTypes then
Tool.CleanPosToCaret(Tool.Tree.Root.StartPos,XYPos);
end;
Result:=Result+' '+SourcePosToFPDocHint(XYPos)+LineEnding;
Result:=Result+'</div>'+LineEnding;
end;
function TCodeHelpManager.GetHTMLDeclarationHeader(Tool: TFindDeclarationTool;
Node: TCodeTreeNode; XYPos: TCodeXYPosition): string;
begin
Result := GetHTMLDeclarationHeader(Tool, Node, xtContext, XYPos);
end;
function TCodeHelpManager.GetPasDocCommentsAsHTML(Tool: TFindDeclarationTool;
Node: TCodeTreeNode): string;
var

13
ide/sourceeditprocs.pas
View File

@ -238,6 +238,7 @@ var
ImageIndex: longint;
HintModifiers: TPascalHintModifiers;
HintModifier: TPascalHintModifier;
HelperForNode: TCodeTreeNode;
begin
ForegroundColor := ColorToRGB(ACanvas.Font.Color);
Result.X := 0;
@ -421,10 +422,14 @@ begin
case ANode.Desc of
ctnClass,ctnObject,ctnObjCClass,ctnObjCCategory,
ctnCPPClass,
ctnClassInterface,ctnObjCProtocol,ctnDispinterface:
ctnClassInterface,ctnObjCProtocol,ctnDispinterface,
ctnClassHelper,ctnRecordHelper,ctnTypeHelper:
begin
case ANode.Desc of
ctnClass: s:=s+'class';
ctnClassHelper: s:=s+'class helper';
ctnRecordHelper: s:=s+'record helper';
ctnTypeHelper: s:=s+'type helper';
ctnObject: s:=s+'object';
ctnObjCClass: s:=s+'objcclass';
ctnObjCCategory: s:=s+'objccategory';
@ -438,9 +443,15 @@ begin
except
on ECodeToolError do ;
end;
if ANode.Desc in [ctnClassHelper, ctnRecordHelper, ctnTypeHelper] then
HelperForNode := IdentItem.Tool.FindHelperForNode(ANode)
else
HelperForNode := nil;
SubNode:=IdentItem.Tool.FindInheritanceNode(ANode);
if SubNode<>nil then
s:=s+IdentItem.Tool.ExtractNode(SubNode,[]);
if HelperForNode<>nil then
s:=s+' '+IdentItem.Tool.ExtractNode(HelperForNode,[]);
end;
ctnRecordType:
s:=s+'record';

3
images/laz_images_list.txt
View File

@ -140,6 +140,9 @@ states/state_unit_circular_reference.png
states/state_unknown.png
states/state_warning.png
codeexplorer/ce_class.png
codeexplorer/ce_classinterface.png
codeexplorer/ce_record.png
codeexplorer/ce_helper.png
codeexplorer/ce_const.png
codeexplorer/ce_default.png
codeexplorer/ce_deprecated.png