SIL functions might be associated with decls from other source files whose symbols we can't necessarily locally link to. The module should be associated with the SourceFile that was compiled.
Assign the location of a switch statement's subject expression to all of
its case statements.
This improves the debugger's stepping behavior in switch statements.
Stepping into a switch now goes directly to the first matching case
(possibly one with a `where` clause that may or may not match). It's
still possible to set breakpoints within `where` clauses.
rdar://35628672
Port multiple test-cases from `test/Constraints/closures.swift`
to SILGen to verify that closures are inferred as having `Void`
result type, and there is no function conversion thunk emitted
to convert from `() -> T` to `() -> Void` for literal closures.
Without this fix, the type reconstruction logic chokes on
demangled subtree of the kind:
kind=DeclContext
kind=Function
kind=Module, text="swift_ide_test"
kind=PrivateDeclName
kind=Identifier, text="_0830B395847924C73A6666B87EFD2ADF"
kind=Identifier, text="patatino"
Fixes the compiler part of <rdar://problem/38248403>
The MSVC environment does not have a `-isysroot` or `-sysroot`
equivalent. Instead, manually expand the sysroot to the path as a
prefix to `/usr/include` and treat the path as a system include
directory. This fixes a number of tests which use `-sdk` on Windows.
Same-type constraints are one of the primary places where potential
archetypes are used explicitly in the GenericSignatureBuilder. Switch
the representation over to a dependent type (represented by a `Type`)
instead, furthering the demise of PotentialArchetype.
If we perform an exit and do not use a terminator, then we will still have a set
insertion point. By unconditionally unsetting it, we gain the property that we
want and are nice to the normal exit case.
Same-type constraints are (still) described in terms of potential
archetypes, so push the "realization" operation for potential
archetypes down into the function that adds a same-type constraint
between type parameters.
GenericSignatureBuilder::addSameTypeRewriteRule() was described in
terms of an equivalence class and a potential archetype. Rework it in
terms of two dependent types (i.e., the anchors of their equivalence
classes), so we don't need to rely on the PotentialArchetype
mechanism.
Make GenericSignatureBuilder::getCanonicalTypeParameter() independent of
equivalence classes. This is primarily cleanup, because all of these
equivalence-class resolution calls were actually dead from the point
where we changed the key for the rewrite-roots DenseMap over to
dependent types.
Rather than keying the rewrite tree roots on equivalence classes,
which imply a mapping through potential archetypes, key on (canonical)
types that are currently the anchors of equivalence classes.
Now that we no longer have DependentMemberTypes within the GSB that don't
have associated type declarations, we can no longer fail when
unpacking type into a RewritePath, so remove a bunch of optionals and
null Type checks that are now superfluous.
The main change here is that we no longer forward ownership through
unchecked_bitwise_cast. The reason why is that unchecked_bitwise_cast creates a
new "reference count" identity to the optimizer. This is reflected in the SIL
ownership model by unchecked_bitwise_cast returning a value with unowned
ownership. We really do not want to traffic in such values, so we copy the value
after the cast to ensure that result is valid.
Found while updating SILGen tests for +0.
rdar://34222540
Don't check SIL_KEYWORDs when we're not in SIL mode.
Lexer::kindOfIdentifier is super hot-path because many of
tokens in a swift source file are keywords or identifiers.
Mark Lacey
Joe Groff
Mark Lacey
Joe Groff
Huon Wilson
Doug Gregor
swift-ci
Slava Pestov
Pavel Yaskevich
Adrian Prantl
Slava Pestov
Sho Ikeda
Rintaro Ishizaki
Davide Italiano
Vedant Kumar
Harlan
Pavel Yaskevich
Davide Italiano
Saleem Abdulrasool
Jordan Rose
omochimetaru
Michael Gottesman
Michael Gottesman
Andrew Trick