Enter forum description here ...
+6
Under review

Paint messages into the editor (10 Seattle and higher)

Uwe Schuster 10 years ago updated by Roman 10 years ago 1
The INTAEditViewNotifier OTA enhancement in 10 Seattle allows drawing into the editor. This can be used to paint the messages directly into the editor.
+6
Under review

New warning: mixing interface and class references to the same object

Anonymous 10 years ago updated by Roman 10 years ago 1
This could be tricky to write, but would be a /very/ useful warning.

See, eg, http://stackoverflow.com/questions/4509015/should-the-compiler-hint-warn-when-passing-object-instances-directly-as-const-in
+5
Planned

Warning request: Calling FreeAndNil on an interfaced type

David Millington 10 years ago updated by Roman 10 years ago 1
var
List : IList<Integer>; // A Spring4D list
...
FreeAndNil(List); // <- bam!

It shouldn't be possible to call Free since you can only call methods defined in an interface on an interfaced type, but FreeAndNil doesn't have any checking and will compile happily with the above code.
+5
Planned

Warn about unused local constants

Anonymous 10 years ago updated by Roman 10 years ago 2
If you have a method which declares some constants, and those constants are not used, no warning is generated by Delphi.  IMO there should be a warning, just like for variables that are not used.

Eg,
procedure TForm1.Foo;
const
 A = 1;
 B = 2;
var
 C,
 D : Integer;
begin
 C := B;
 Caption := IntToStr(C);
end;

Delphi warns about unused variable D, but not unused constant A.
+5
Completed

W511: false positives (Object 'xxx' created in try block

dummzeuch 10 years ago updated by Roman 10 years ago 3
The warning W511: Object 'xxx' created in try block is annoying because it is common practice to write code like this:

bla := nil;
blub := TBlub.Create
try
bla := TBla.Create;
// ...
finally
bla.Free;
blub.Free;
end;

I realize that is is difficult to determine whether the object variable is being initialized with nil (how far in front of the try do we look?) but we need a way to reduce the amount of such warnings otherwise they will just be turned off.

(I am sure I am not the first one to notice this, but I the look up did not find anything.)
+4

Check prefix for parameter

Kai Frentzel 9 years ago updated by Marcus Mangelsdorf 5 years ago 1

Check if the paramter of a method have a prefix:

var Parameter: v

out Parameter: o

other Parameter: a


So you can see what type of parameter is used.

+4
Answered

Command Line Client: Define rules per Parameter

Anonymous 10 years ago updated by Roman 10 years ago 6
FixInsightCL -- project=\source\example.dpr --rules=W507;508;C105;C106
+4
Fixed

[W513] False positive when using index specifier

Uwe Schuster 10 years ago updated by Roman 10 years ago 3
Using an index specifier in format statements creates false positive W513 warnings.

ShowMessage(Format('%d %0:d', [1]));//OKAY - output "1 1"
ShowMessage(Format('%0:d %0:d', [1]));//OKAY - output "1 1"
ShowMessage(Format('%0:d %0:d %1:d', [1, 2]));//OKAY - output "1 1 2"
ShowMessage(Format('%0:d %0:d %1:d %d', [1, 2]));//ACTUALLY AN ERROR, because last %d requires a third arguments array item
+4
Under review

[W504] False positive with classes with multiple constructors where one calls the other

Uwe Schuster 10 years ago updated by dummzeuch 9 years ago 6
A constructor that calls another constructor in the same class leads to false positive W504.

type
TFoo = class(TObject)
public
constructor Create;
end;

TBar = class(TFoo)
public
constructor Create;
constructor CreateEx;
end;

//<- http://fixinsight.userecho.com/topic/701447-w504-false-positive-with-objects-inherited-from-tobject/
constructor TFoo.Create;
begin

end;

constructor TBar.Create;
begin
inherited Create;
end;

constructor TBar.CreateEx;//<- False positive W504
begin
Create;
end;
+4
Planned

objects that should be .free but not called .free

Anonymous 10 years ago updated by Krasimir Ivanov 10 years ago 3
Objects like stringlists should be destroyed by .free; scan for .free for the object if not found flag it
(especially in destroy methods)