Ceci est la combinaison de 338+ commits.
Make set of classes to mirror types
Implement capture conversion
Document
Doc
Implement contains for targs
Implement toString
Fully implement subtyping
Check for reifiability
Implement unchecked, fix array subtyping
Test rec typevar building
Test primitive subtyping
Test array subtyping
Test wildcards subtyping
Doc
Rename primitiveType
Reify conversions
Test boxing
Make constants for common types
Test type param mutual recursion
More defensive validation
Implement numeric promotion
Checkstyle
Implement supertype set
Implement lub
Fix infinite recursion
Fix lub bugs
Use linkedhashset for stable ordering
Add primitives to common types
Move common types into type factory
Try a lazy class resolver, needs a symbol table
Improve lazy resolver
Implement conditional expr typing
remove poly impl
Represent primitive wrappers differently
Better compromise for primitive wrappers
Extract wildcard interface
Extract array type interface
Refactor to extract interfaces
Don't depend on initialization of jprimitiveType
Finish pretty printer
Remove dependency on reflection
Fix class initialization trouble
Move to type constants
Use regular impl for OBJECT
Encapsulate ops into TypeOps
Add inference var to model
Impl some ops
Add some type inference algos
Invocation context compatibility
Add incorporation
Generify bound set with ExprOps
Add applicability tests
Fix compil
Add incorporation actions
Implement incorporation
Add inference steps
Implement brute force walk strategy
Remove some type params
Wire in everything
Implement methodtype
Access methods from JClassType
Represent enclosing types
Work on overriding
Implement expr ops
Catch easy cases
Diamond inference
Fix pretty printer
Fix concurrent mod
Test
Add reflect info to JModifier
Add symbolic type declaration
Most specific check
Test with nested invocation
Test lub
Add constraints for lambdas and all subexpressions
Resolve full call chain with lambdas
Set partial results on nodes
Test chain
Doc
Generalise expr mirrors
Fix context
Add invocation mirror
Add support for method references
make infer static
Cleanup interface
Fix constructor access
Test method reference
Cleanup method ref types
Test constructor reference
Test overload resolution, fix TODO
Fix ctdecl of mref on non-ground target type
Add graph walk strategy
Document
Use toposort
Make enum constant implement ctor invoc mirror
Work on context
Test conditional expr type
Handle switch exprs uniformly
Fix bugs
Add type inference performance test case
Add overload resolution tests
Cache result of overload selection, only recompute invocation
Optimise common case in graph building
Optimise propagation by merging variables
Fix some tests, cleanup
Preserve applicability phase
Improve jsinglechildnode
Add way to get a field's type
Make more complex stress test
Cache bound check results
Type projection for inference
Simplify lazy type inference of var ids
Improve memory usage
- reuse constant enum sets (by far the biggest leak, given the number of PropagateBounds created)
- implement substitution without a visitor
Optimise imports
Cache hash of classes
Cleanup
Add overloads test
Fix context fetching
Fix lub bug
Test switch expr
Fix rebase
Remove useless type
Factorise poly check
Remove base poly expr
Fix array initializer
Remove duplicated numeric literal typing
Fix inferred iterable type
Move method resolution phase to upper level
Delete useless var
Commit pr plan
Remove useless method
Fix enclosing type comb rule
REVERT ME Remove partial enclosing type support
Add package info
Put task list in branch description
Fix old rebases
Fix rebase
Simplify for left recursive ops
Fix comments
Fix rebase
Revert "REVERT ME Remove partial enclosing type support"
This reverts commit 8080ff1585b3a760fafc957282771baf716f3c7f.
WIP base type mirrors on symbols
Make JMethodType not a JTypeMirror
Figure out getSymbol & type vars
make type factory non-static
Add a parameter to visitors
Fix compilation
Use symbol table in lazy type resolver
Move package
Fix most tests
Move internal api around
Specify some stuff
Split reflect impl from API
Make AST impl
Equality routines
Fix tests
Move internal symtable doc
Improve symtableResolver ergonomics
Poly res tests
Make AST type factory
Update
Make lambda expressions not a MethodlikeNode
Build local var sym
Update for switches
Make Infer not static, fix logging
Don't expose visitor nature of SymbolResolver
Cleanup
Improve type error handling
Don't throw away CTdecls for an arg mismatch
Fix more tests
Local symbol tables
Symbol table looks in interfaces
Incompatible changes that should stay on this branch and not be squashed
ResolveResult
Explicitly typed lambdas
Fix some static bugs
Fix a lot of bugs
Use FQCN symtable
Move parsing contexts to upper level
Cleanup
DSL to test types
test subst
Dont create an exception for each failure
Stack trace creation takes a significant amount of time
Remove laziness for fetching method streams
Streams obfuscate performance analysis by
delaying the computation until the last
moment.
Fix some bugs with unresolved classes
Also measure performance: full typeres
is around same time as parsing. This is
great. At this point 80% of all types
are resolved (though some type inference
results are probably incorrect). Mostly
this comes from the fact that there are
still AmbiguousNames in the tree.
Fix problem with varargs
Handle enclosing types
Enclosing types
Fix compil
Add another stress test
Refactor primitive subtyping
Fix rebase
Fix rebase: tests
Figure out type factories WIP
Move type ops into TypeOps
Move AsSuper
Figure out type factories WIP
Make TypeSystem object
wip
WIP
WIP
Make typeops static
Fix grounding routine
Fix bug with return type
Start fixing tests
Cleanup primitive types
Fix some tests
Add todo
Remove JDK test dependency
Test cases lubbing String and
StringBuilder produce different
outputs on JDK [8, 11[ and 11+, because
StringBuilder was made a Comparable<StringBuilder>
in JDK 11
Implement most specific method selection
Drop JVariableSig from symbol table
Use asOuterSuper instead
Fix local var type inference with foreach.
Fix a lot of stuff based on jdk 12 run
Make type system own symbol factories
Fix intersection with bound
Fix standalone ternary types
Capture field access type
Eg class Foo<T> { T[] field; }
Foo<? extends T>.field : capture(T)[]
Add tests
Delete lexical substs
Fix reflected owner type
Add graph viz
Fix bug with graph reduction
Optimise ivar dependency reduction
by a lot. The previous 60s stress
test now takes 600ms.
Btw at this point type res for the
whole JDK 12 codebase takes 25 secs,
down from 175 on 6.20.0 (7x speedup).
Implement inherited field/class lookup
Fix scoping inside switch statements
Fix a few bugs
Handle inherited methods
Interfaces should inherit Object methods
Move lub into TypeSystem
Handle class types induced by intersections
Fix lambda congruence
Test lambda with intersection type
Fix inference
Fix same type check using equals
Simplify intersection type induction
Remove type sys extension
Simplify sym factories
Finish symbol factory streamlining
Document
Cache non-erased symbols separately
Doc
Revert, erased types are only raw
Get rid of generic constants in TypeSystem
Remove some dead code
Fix exact method reference
Improve unchecked conversion handling
Fix dependency of delegated ivars
Improve logging, fix a few bugs
Test enclosing types
Improve loggin
Print file location
Fix subtyping for wildcards
Fix standalone method types
Fix boxing conversion
Fix promotion on unary exprs
Implement special treatment of getClass()
Add tests for anon classes
Make symbol tables use lists for methods
Fix method reference with void target type
Move graphUtils
Make unresolved types bottom
(instead of top)
It's more likely to be useful. Eg.
Unresolved var = ...;
knownMethod(var);
Here, var must conform to the parameter,
if it is unresolved, we assume that's the
case. Otherwise we would fail resolution
of knownMethod for this call site.
The reverse situation is rarer.
Fix conversions in loose phase
Make JInferenceVar a class
Hide TypePair
Remove special string type
Fix toString of anon classes
Implement overload specificity for generic methdos
Fix anon class ctors
Fix Object methods not in scope in interfaces
Fixing anon class ctors WIP
Fix rebase
Cleanup
Print type var bounds
Fix tests, improve pretty printing
Hide ast sym factory
Fix array method erasure
Fix superclass, uncover bug with substitution
Substitute type param bounds
Make Array have Object methods
Fix duplicated logging categories
Make root symbolFactory thread safe
Fix overload ambiguity with hiding
Fix exact method when they shadow each other
Make PMultimap type
Make shadowGroup
Make a few utilities to replace import tables
Replace other tables
Cleanup
Compat with old impl
Fix rebase
Port to using sigs
Make base class for shadow groups
Fix method group
Test shadowing of inherited members
Fix bugs with tparams
Specialize to StringMultimap
Big optimizations
Simplify a lot of things, remove caching
of getAllMethods
Factorize group implementations
Add resolveFirst
Fix bug with ctor invocation
Fix type parsing for union types
Generify multimap
Implement nextShadowGroup
Remove unused API of pmultimap
Use interface where possible
Fix tests
Use singleton resolvers more frequently
Remove commons collections dependency
Tries don't make a significant difference
in execution time. Mostly because tries
used in symbol tables are very small.
Remove some api of jtypemirror
Fix shadow barriers
Fix accessibility check for protected member
Qualified ctor invocations have access to inner class name
Make strict stream for profiling
LOOK AT ME strict streams
Strict streams are actually *much* more
efficient for our use case
Extract some stuff into CollectionUtil
Make methods shadow each other
doc
Simplify OptionalBool
Improve strict stream
Eventually I'll remove it
Doc newer symtable
Make PMultimap type
Make shadowGroup
Make a few utilities to replace import tables
Cleanup
Checkout newer sym table from typeres branch
Port
Checkout tests
Port tests, remove old impl
Extract augment function
Move classes back into internal package
Abstract stuff away for pmd-core
Optimise singular map case even more
Fix nextShadowGroup WIP
Make ShadowIterator to replace getNextGroup
Use chain iterator
Add tests
Finish impl
Add tests for supertype enumerator
Add tests for method shadowing in imports
Port to using types etc
Fix tests
Fix outdated tests
Fix anon class ctors
Fix more outdated tests
Object methods should be in scope in interfaces
Fix compil
Make simple signature parser
Make stubs
Figure out loading logic
Progress on type param parsing
Do away with nested classes
Class signatures
It works!
Parse tvar bounds lazily
Fix a lot of stuff
No errors on pmd-core
JDK 13 under 80s
Implement toString everywhere
Try to make the whole thing thread safe
Still a spurious NPE, access flags are weird.
For j.l.invoke.DelegatingMethodHandle
(declared as `final class Holder {}`) the
access flags from the class file are 0x32, and
the enclosing type is null, while when accessed
through reflection, the access flags are correctly
0x10. The class is engineered through VM magic
so idk what happens
Remove shared caching of TypeSystem
The sub caches are not useful anymore
and creating them all the time is wasteful
Add some tests
Fix improper locking
Reorganise typeSystem initialization
Change the name
Doc
Opts
Optimise away some expensive lookaheads in the parser
Doc
Fix modifiers
Optimise big switches in parser
Placing token decls that are frequently used together closer
increases the chance that the compiler generate a TABLESWITCH
instruction instead of a LOOKUPSWITCH. Table switches take
constant lookup time, while lookupswitch is linear. Selection
of table switch is now done for the biggest switches of the
parser: the one in types, in modifiers, in statements, and
at the start of expressions. Other lookup switches are unimportant
because they have very few labels (typically 2).
Optimise variable initializer lookahead
make test rule noop
PARSER Optimise common branches in expressions
PARSER opt blocks & statements
doc
Don't accept void by default
Split signature parsers
Simplify type param parsing
Simplify type params parsing
Some optimisations
Tests
Simplify synchronization
Factorize synchronization logic
Move ConsList into pmd-core
Prune more empty nodes
Use single map for asm resolver
Remove changes to parser
Add option to suppress type inference log entry creation
Use soft references to allow class stubs to be GCed
Fix rebase
Add kotest-runner-junit5-jvm as a dependency,
in pmd-java. This makes kotest discoverable
as Junit tests, which IDEs can pick up on (at
least IntelliJ does).
Update kotlin version to latest stable (1.3.72)
The columns that are reported by CPD were inconsistent across languages
before. A language like Java (using a JavaCC-based tokenizer) would use
a width of 8 for tabs, whereas a language like C# (using an Antlr-based
tokenizer) would use 1 instead.
This includes unit tests for most languages to ensure a tab character is
counted as 1. The configuration for JavaCC has been adjusted to respect
this as well.
This removes junit-vintage-engine as a test dependency
as well as kotlintest-runner-junit5.
The engines are only needed during test execution, but should
not be available for test compilation.
For this to work, the latest surefire plugin is required.
Replace SideEffectingVisitor with JavaVisitor
The new visitor is generic. We don't actually need the
old Object->Object visitor, this could just be the new
generic visitor but erased
Port language level checker
Move delegators
Remove old accept methods
Remove reduced adapter
Cleanup some visitor
Make ant wrapper replace old visitor completely
Doc
Add DeprecatedUntil700 annotation
Add top interface for visitors
Convert JSP visitors
Checkstyle
Fix java module
* Avoid using symlinks, this is very difficult to get working
under Windows
* Provide names for the different scala modules
* Rename pmd-scala to pmd-scala-common
* Restore main module pmd-scala for backwards compatibility
