"Amir Michail" <am******@gmail.com> wrote in message news:<cf********@odak26.prod.google.com>...
I was wondering if there is a tool that will perform some heuristic
checking of actual and formal parameters to warn about likely errors.
Such a tool could check that formal and actual parameters have similar
names.
For example:
def plot(x,y): ...
plot( x1, y1 ) # ok
plot( y1, x1 ) # not ok, but this is ok: plot (x=y1, y=x1)
I'm not sure how generally useful this would be. There are just too
many circumstances where the name in the definition and the name you
call with are legitimately quite different:
def plot(x, y):
....
plot(square.width, square.height)
for column in range(8):
for row in range(8):
move_pawn_to(column, row)
plot(column, row)
for i in range(10):
for j in range(10):
plot(i,j) #along with other stuff using the loop variables
def write_log(string_to_send): # probably a log.write method in
real life
....
write_log(server.error_message)
write_log(user.username)
def wait_for_connection(socket):
....
wait_for_connection(servers["yahoo"])
It _might_ be somewhat useful to have something that detects ONLY when
you are calling with similar names in a different order. Even that
isn't necessarily useful, there might be non-trivial cases something
like:
class generic_tree():
def insert_member(child, parent):
class gui_window_tree(our_tree):
class crypto_algorithms_tree(our_tree):
....
(child, parent) = fork_wrapper()
GUIWindows.insert_member(child, parent)
EncryptionAlgorithms.insert_member(parent, child)
where flip-flopping names made sense. Though this isn't a
particularly great example, and it might generally be a decent lint
warning.
