| Age | Commit message (Collapse) | Author |
|---|
|
|
|
|
|
|
|
|
|
|
|
A bug is fixed, but there are more problems.
Modify erl_types.erl like this:
-define(EXPAND_LIMIT, 500).
and bogus warnings are output (again).
Callbacks and specs are compared (subtype) in dialyzer_behaviour. If
they are expanded to different depths, then invalid warnings can be
generated.
|
|
|
|
|
|
|
|
|
|
The lack of this caused problems on some Windows machines
|
|
|
|
Dsa is outdated and not supported by modern OpenSSH
|
|
|
|
|
|
|
|
The guard should check that the TLS version is at least TLS-1.2.
|
|
Refactor get_name/1 to facilitate an optimization in the next commit.
|
|
Correct conversion errors form commit d2381e1a8d7cd54f7dc0a5105d172460b005a8fb
|
|
|
|
|
|
make_path() returns a tuple whose second element is not used by
any of its caller. Eliminate the tuple.
Also avoid calling filename:dirname/1 when we already have the result
stored in a variable, and avoid calling filename:basename/2 on a
complete path when we already have the last part of the pathname
stored in a variable.
|
|
absname/1 is quite expensive, so we should not call if we already
have a normalized absolute path.
|
|
The same filtering of sub directories is done in archive_subdirs/1
and try_archive_subdirs/1. Actually, archive_subdirs/1 does nothing
useful. It can be removed and all_archive_subdirs/1 can be renamed
to archive_subdirs/1.
In try_archive_subdirs/1, we can also replace filename:join/1
with the cheaper filename:append/1, since we know that pathnames
have already been normalized.
|
|
It is faster and easier to use filename:split/1 and filename:join/1
than use four different 'filename' operations. Each call in the
original call first flattens the input list, and then traverse the
entire string to the end. So there are roughly 8 complete traversals.
In comparison, filename:split/1 will traverse the input string
twice (once to flatten, once to split) and filename:join/1 once.
For background on why this optimization is worthwhile, here is the
result of profiling the start-up of the run-time system on my computer
(done before this optimization):
$ $ERL_TOP/bin/erl -profile_boot
.
.
.
filename:join1/4 - 13573 : 13805 us
erlang:finish_loading/1 - 27 : 19963 us
filename:do_flatten/2 - 29337 : 49518 us
erlang:prepare_loading/2 - 49 : 52270 us
Note that filename:do_flatten/2 ends up in second place, almost
as expensive as erlang:prepare_loading/2. Your mileage may vary,
depending on the length of $ERL_TOP and the number of extra
directories added to the path using $ERL_LIBS.
|
|
When using a code archive for an application, it should be possible
to store some directories for the application outside of the archive
file (for example, shared libraries that will not work inside an
archive). Make sure that we test that a directory outside of the
archive file really works.
|
|
* jlouis/stdlib/implement-lists-join/PR-1012/OTP-13523:
Implement lists:join/2
|
|
* bjorn/compiler/core-erlang-fixes:
Slightly optimize core_pp
v3_core: Don't depend on sys_core_fold for cleaning up
|
|
* erlang/pr/1006:
Use define-derived-mode to define erlang-mode
|
|
|
|
|
|
|
|
* gomoripeti/fix-cpu_sup_spec/PR-1029/OTP-13526:
Fix type spec for cpu_sup:util/1
|
|
'...' is allowed at the end of of association types.
|
|
Type information is stored in erl_bif_types for certain BIFs.
This fact must be stated in the type specification for the
stubs that are superceded by erl_bif_types.
* Shadowed by erl_bif_types: maps:from_list/1
* Shadowed by erl_bif_types: maps:get/2
* Shadowed by erl_bif_types: maps:is_key/2
* Shadowed by erl_bif_types: maps:merge/2
* Shadowed by erl_bif_types: maps:put/3
* Shadowed by erl_bif_types: maps:to_list/1
* Shadowed by erl_bif_types: maps:update/3
|
|
|
|
|
|
Opaque singleton keys have the unfortunate property, unlike any other
singleton type, to overlap with other singleton types that do not have
the same internal representation. Therefore, we must not keep opaque
singletons in the Pairs list in a map type.
|
|
t_subtract/2 would break its postcondition by always returning the
underapproximation none() when given a variable on the right hand side.
This broke map type parsing, since it relied on t_subtract/2 to tell it
when map keys would shadow each other.
|
|
Opaque keys in maps broke an assumption in
erl_types:mapmerge_otherv/3 (that the infinimum of a singleton type and
some other type would either be none() or that same singleton type),
causing a case_clause crash.
|
|
28a4a5057ab9 mistakenly used the non-existing type cerl:tree() instead
of cerl:cerl().
|
|
dialyzer_typesig:traverse/3 would perform an unsafe optimisation when
given a cons pattern that contained a map and could be folded into a
literal with cerl:fold_literal/1. In this case, when traversing the map
a type variable would be generated, but this variable would be dropped
by the erl_types:t_cons/2 constructor by in turn calling t_sup(),
producing the overapproximation any(). However, in this particular case,
dialyzer_typesig:traverse/3 is not allowed to overapproximate, since its
result is used in an EQ-constraint.
Although erl_types:t_tuple/1 does not overapproximate like t_cons/2,
which makes the bug unlikely to affect tuples too, the fix was
nevertheless applied defensively to the case of tuples as well.
Also, fix a bug where dialyzer_utils:refold_pattern/1 would generate
syntax nodes with two {label, _} attributes.
|
|
Because the type representation has changed, old PLTs are not
compatible. We update the version to 2.10 because of this.
|
|
|
|
This is analogous to the case of nil. Since #{} is a base-case of almost
all map types, contract and success typing sharing #{} does not mean
much, and is often sign of a violation.
|
|
mk_constraint_list/2 was simplifying (C OR TriviallyTrue) to (C), which
is obviously wrong.
|
|
The assumption that 'try' nodes were only used to wrap entire guards is
no longer true.
We're still swallowing warnings when the handler returns successfully.
Unfortunately, bind_guard/5 would need to be refactored to return a new
state in order to generate those warnings.
|
|
Dialyzer relies heavily on the assumption that the type of a literal
that is used as a pattern is the type of any value that can match that
pattern. For maps, that is not true, and it was causing bad analysis
results. A new help function dialyzer_utils:refold_pattern/1 identifies
maps in literal patterns, and unfolds and labels them, allowing them to
be properly analysed.
|
|
|
|
|
