| Age | Commit message (Collapse) | Author |
|---|
|
The pre-defined types array(), dict(), digraph(), gb_set(), gb_tree(),
queue(), set(), and tid() have been removed.
|
|
Use F/A rather than M:F/A for local functions.
|
|
"... when _ :: ..." used to compile, but Dialyzer crashed.
|
|
sys_pre_expand used to crash. There is no known reason to
allow -callback attributes with explicit module.
|
|
product/_, union/_, range/2 as well as tuple/N (N > 0), map/N (N > 0),
atom/1, integer/1, binary/2, record/_, and 'fun'/_ can now be used as
type names.
|
|
|
|
When redefining and exporting the type map() erl_lint erroneously
emitted an error. This bug has been fixed.
|
|
|
|
* bjorn/stdlib/otp_internal:
otp_internal: No longer warn for funtions removed in R13B
otp_internal: Postpone removals from R17 to OTP 18
|
|
The grace period is over.
|
|
|
|
This will change in future release.
|
|
|
|
erl_lint has since R13B emitted warnings whenever any of the types
arity(), bitstring(), iodata(), or boolean() were re-defined. Now
errors are emitted instead.
|
|
Since Erlang/OTP R16B the linter has not emitted warnings when
built-in types were re-defined. This bug has been fixed.
Thanks to Roberto Aloi for reporting the bug.
|
|
* nox/maps-improve-erl_lint:
Improve linting of map expressions
|
|
* nox/compiler/lint-shortcircuit-ops:
Properly lint shortcircuiting operators
|
|
The deprecation of the built-in types dict/0 and so on had as
side-effect that it was impossible to switch to dict:dict/2 and so on
without getting warnings either in the the previous release (R16B) or
the current one (17.0).
By including the attribute
-compile(nowarn_deprecated_type).
in an Erlang source file warnings about deprecated types can be
avoided in 17.0.
The option can also be given as a compiler flag:
erlc +nowarn_deprecated_type file.erl
|
|
|
|
Map fields are put in their own function instead of being clauses of expr/3.
Also, invalid map construction expressions now emit one error per ':=' field,
at the location of said field instead of one for the whole expression,
furthermore, such warnings do not stop linting of their key and value
expressions anymore. Ill-formed maps constructions are now also properly
detected in guard expressions.
|
|
Shortcircuiting operators are not real functions and can't be used as
such with erlang:'andalso'(...) and erlang:'orelse'(...).
Reported-by: Ulf Norell
|
|
The types array(), dict(), digraph(), gb_set(), gb_tree(), queue(),
set(), and tid() have been deprecated. They will be removed in OTP 18.0.
Instead the types array:array(), dict:dict(), digraph:graph(),
gb_set:set(), gb_tree:tree(), queue:queue(), sets:set(), and ets:tid()
can be used. (Note: it has always been necessary to use ets:tid().)
It is allowed in OTP 17.0 to locally re-define the types array(), dict(),
and so on.
New types array:array/1, dict:dict/2, gb_sets:set/1, gb_trees:tree/2,
queue:queue/1, and sets:set/1 have been added.
|
|
* josevalim/suppress-all-auto-imports:
Allow all auto imports to be suppressed at once
OTP-11682
|
|
Reported-by: Michele Miron
|
|
|
|
This patch introduces the no_auto_import attribute:
-compile(no_auto_import).
Useful for code generation tools that always use the
qualified function names and want to avoid the auto
imported functions clashing with local ones.
Implementation wise, we chose to have a special flag
'all' to avoid doing many set lookups when checking for
suppression.
|
|
Conflicts:
bootstrap/lib/stdlib/ebin/erl_lint.beam
|
|
When reporting a field redefinition in a record, erl_lint can forget
about some old unused variables.
f() -> X = 1, #r{a=foo,a=bar,a=qux}.
|
|
Variables used in the body of a try expression were marked as unsafe
*and* used, which makes no sense as an unsafe variable can't be used.
Function vtsubtract/2 is used to forget usage of such unsafe variables.
Reported-by: Paul Davis
|
|
When analyzing complex expressions (i.e. comprehensions, cases, tries,
ifs and receives), erl_lint does not forget about old unused variables
when returning the updated variable table. This causes a bug where old
unused variables are not recorded as such:
t(X, Y) ->
#r{a=[ K || K <- Y ],b=[ K || K <- Y ]}.
As erl_lint uses vtmerge_pat/2 to merge the results of the analysis of
the two list comprehensions, X is marked as used and the warning is not
emitted.
The function vtmerge_pat/2 is used instead of the similar vtmerge/2
which does not mark multiple occurrences of a variable as usage to
handle cases like the following one:
t(X, Y) ->
#r{a=A=X,b=A=Y}.
Other simpler expressions like conses, tuples and external fun
references do not correctly follow this behaviour, e.g. A is not marked
as used in the following code:
t(X, Y) ->
{A=X,A=Y}.
This commit fixes both issues and makes erl_lint not return old unused
variables in updated tables and makes all compound expressions use
vtmerge_pat/2.
Reported-by: Anders Ramsell
|
|
* maint:
Fix a bug in the linter regarding the 'fun M:F/A' construct
|
|
If the fun M:F/A construct was used erroneously the linter could
crash.
Thanks to Mikhail Sobolev for reporting the bug.
|
|
It makes no sense to be able to do `<<...,Rest/binary>> <= ...` in a
comprehension. The related Dialyzer test is removed.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Tuple funs were deprecated in R15B (in commit a4029940e309518f5500).
|
|
The run-time warning for use of tuple funs will not catch the use
of literal tuple funs, such as:
if
{erlang,'+'}(3,X) =:= 0 -> true;
true -> false
end.
Therefore, add a compile-time warning to give users some warning
before they stop working in R16.
|
|
|
|
Attempting to call is_record/3 (without an erlang: prefix) from a
guard if there was a local function named is_record/3 would cause
a compiler crash. For consistency with other guard tests, disallow
the call.
is_record/2 in a guard will still be allowed (and work correctly)
even if there is a local is_record/2. It could be argued that
is_record/2 should be handled in the same way as is_record/3,
but changing that now could break working code.
|
|
If a guard test (such as is_list/1) has a local definition in a
module (or is imported), erl_lint will reject a call to it from
a guard if the call is not at the top-level:
foo(L) when is_list(L) =:= true -> %% Will be rejected.
ok.
is_list(_) -> ok.
But if the call is at the top-level, it will be accepted (and
cause a crash in a later compiler pass):
foo(L) when is_list(L) -> %% Will be accepted by erl_lint
ok.
is_list(_) -> ok.
This inconsistency was an oversight introduced when it became
possible to override BIFs with local definitions.
|
|
Running Dialyzer on the test suites revealed a few type errors.
|
|
|
