►
From YouTube: async-await implementation plans (2019.02.26)
Description
Meeting to discuss impl strategies for various outstanding async-await bugs.
The Dropbox Paper doc that we were using is available here:
https://paper.dropbox.com/doc/2019.02.26-impl-discussion-notes--AYcSQHRnxOOCEjqwYjqmcUjmAg-5v4Q2n9cRn2KYgVyWMphQ
A
A
B
Yeah,
so
this
is
I
mean
this
is
the
same
issue
rate
of
that
it's
adding,
plus
whatever
light,
and
you
had
when
our
tight
parameter
might
not
necessarily
outlive
that
lifetime.
These
are
all
boil
down
to
the
same,
like
our
captures.
Behavior
for
infiltrate
isn't
quite
like
when
you
add
Plus,
take
something,
isn't
quite
what
you
want
here,
or
at
least
like
we
want
something,
that's
more
expressive
than
the
naive
version
of
that
yeah.
Can
you
just.
B
A
B
And
so
the
explicit
lifetime
is
sort
of
the
the
worst
version
of
this
right,
which
is
more
better
depending
on
how
you
look
at
it
and-
and
what
should
be
happening
here
right
is
that
if
we
have
this
generic
on
T
here,
if
I
add
the
T
Jannard
above,
what
should
happen
is
that
our
return
type
should
be
bounded
by
the
lifetime
of
T
and
by
the
lifetime
of
take
a
so
it
should
outlive.
No,
it
should
not
live
any
type
parameter
or
lifetime
parameter.
B
It
should
live
for
the
minimal
intersection
of
all
of
those
right,
but
instead
what
happens?
Is
we
just
try
and
we
do
a
dumb
pass
over
the
arguments
in
in
the
ast.
We
count
up.
We
look
for
all
the
lifetimes
and
if
there
are
multiple
different
lifetimes,
we
give
an
error,
and
if
there's
only
one
lifetime,
we
just
add
it
as
a
plus
tick.
Whatever
that
lifetime
was.
A
B
B
A
A
A
B
A
Okay,
part
of
what
were
like
the
challenge
of
well
with
the
issue
of
alighted
lifetimes.
That
seems
like
fairly
specific.
Maybe
all
of
this
is
to
the
details
of
how
we're
doing
the
lowering
right,
yep,
I,
guess
I'd,
rather
first
figure
out
like
what
we
think
the
compiler
should
do
kind
of
conceptually
and
then
worry
about
the
lowering
problem,
but
I
guess
this
is
the
right
answer.
A
It
wants
to
be
doing
like
some,
like
you
said,
introducing
some
sort
of
found
that
covers
all
the
captured
things,
maybe
because
it's
not
the
only
solution
here
right
in
a
sense,
there's
no
need
for
a
in
this
particular
case.
There's
no
real
need
for
this
plus
to
casing
and
some
notion.
If
we
do
sugar,
this
all
right
hold
on.
Let's
take
sugar
this
one!
Second,
if
we
do
sugar,
this,
like
I,
guess
I'll
use
the
excess
starch
n-type,
notation,
yeah
yeah
the
problem
to
go.
A
B
Which
isn't
implemented
correctly,
like
implemented
properly
like,
should
be
able
to
reveal
its
type
within
the
module.
It's
it's
a
little
thing
about
how
just
in
general
existential
type
next
to
a
function,
isn't
the
same.
It's
actually.
You
won't
like
a
module
surrounding
the
function
and
the
existential
type
declaration
right.
Sorry,.
B
A
B
A
A
B
Not
only
worried
about
that,
but
I'm
worried
about
that.
I'm
I'm
still
doing
this
behavior,
where
I'm
sort
of
implementing
alighted
lifetimes
during
during
lowering
in
general,
right
and
and
in
that
I
have
to
also
replicate
all
the
errors
that
you
would
normally
get
via,
like
alighted
lifetimes
in
a
function,
signature
and
things
like
that
and
I.
Don't
think
that
that
will
happen.
That
I,
don't
think
that
just
falls
out
yeah
okay.
A
So,
let's
push
that
on
the
stack
for
one
second
and
we'll
come
back
to
it,
because
I
made
my
main
question.
I
think
it
is
true,
though,
that
apart
from
that,
there
is
no
like
if
we
had
a
nice
scheme
for
doing
this
Laureen.
But
basically
you
need
some
way
to
refer
back
to
the
alighted
lifetime
in
the
compiler.
They
have
a
name
right,
they'll
get
given
individual
indices,
anonymous
zero
and
on
this
one
the
problem
is
that
happiest.
B
A
B
A
The
problem
is,
then,
the
other
problem
you
were
like
there
was
this
bug
we
found
right
where
because
like,
if
you
do,
if
you
do
something
like
this
there's
a
implicit
to
a
static
that
gets
added
here
all
right
and
you
weren't
quite
handling
that
logic
correctly.
Precisely
because,
as
you
said,
you
like,
we,
we
creating
that's
like
the
whole
dry
problem,
we're
trying.
B
To
eliminate
yeah
I
mean
I
was
I
was
literally
like
just
detecting
that
that
was,
that
was
an
alighted
lifetime
and
sticking
a
tick
underscore
on
the
end
and
I
think
that
we
can
like
we
can
do
better
than
that.
Obviously,
now
that
I
know
what
the
actual
like
I
didn't
consider
this
case
at
all
when
I
was
writing
that
logic,
so
right
so.
A
So
yeah
so
I
guess
to
set
what
I
would
what
I
would
like
to
do
is
I
would
like
to
lower
to
something
like
this
yep
already
invoke.
Future
lowers
to
an
existential
type
with
a
funky
scope
declaration
right
all
right
internally
in
the
compiler
we
I'm
using
a
vague
sense
of
lower
here,
but
we
handle
it
like
that.
I,
don't
know
if
yeah
it's
reflected
in
here.
B
A
And
I
would
like
I,
don't
know
what
I
would
like
to
do
about
this.
A
lighted
lifetime
situation,
but
I
know
that
what
I
don't
want
to
do
is
like
what
you're
saying
we
do
now,
basically
of
like
iterating
through
and
giving
them
well
it
yeah
I
would
like
to
look
at
the
code
and
see.
Can
you
figure
out
a
better
way
to
handle
that
I?
Guess
I,
guess
that's
what
it
comes
down
to
that
this!
This
logic
is
such
a
mess,
though
so
maybe
the
answer
is.
B
A
A
B
B
A
A
A
A
B
A
Well,
you
never
know
it's
like.
Is
this
the
last
educator,
or
did
you
not
yet
get
there
right,
but
I
think
trying
to
remember,
because
I
made
a
few
versions,
there
was
at
least
one
version
where
I
moved
this
logic
kind
of
into
here
Laureen,
but
I
think
it
looks
like
I
ripped
that
out
so
I
believe
the
only
real
special
case
is
exactly
okay.
Yes,
so
in
fact
right
so
what
happens
is
in
the
case
where
we
have
a
didn't
rate?
A
A
A
A
B
A
A
Yeah
so
I
think
we
probably
can,
if
we
in
the
same
place
like
I,
think
the
way
we
probably
want
to
handle.
This
is
actually
two
gurus
a
mode
and
anonymous
life
timer
or
something,
maybe
least,
that's
what
that
infrastructure
was
for,
and
so
we
could
imagine
setting
a
mode
such
that.
Then,
when
we
encounter
the
it
may
even
be
the
same
mode
to
create
cram
a
term
odiously
kind
of
what
we
wanted
to
want
to
make
named
parameters
for
them.
B
B
A
A
A
B
B
A
B
I,
it's
still
a
problem
like
it
seems
like
I,
still
think
we
should
fix
it.
It's
just
like.
If
we
can
skip
the
infiltrate
you
sugaring
of
pasty,
sugaring
of
a
stinking
and
dude,
do
something.
That's
based
on
the
named
existential.
Instead.
I
think
that
right
that
allows
for
it
in
its
no
nor
a
blocker
freezing,
FM
yeah.
A
B
Think
away
I,
don't
think
so
I
mean
because
because
the
whole
issue
is
that
we
we
didn't
want
a
name
like
since
today.
The
only
way
to
find
a
lifetime
is
to
either
comet
as
okay
or
to
have
it
in
a
captures
like
a
dummy
capture
straight
yep,
that's
part
of
the
bounds
and
we
we
can
sidestep
that
by
just
adding
it
directly
to
the
parameters
of
the
accidental
type.
If
we
don't
use
the
infiltrate,
lowering
mechanisms,
yep.
A
B
B
A
B
Then
so
one
other
key
things
that
we
identified
as
a
potential
like
backpack
hazard
for
async
FN
was
this
drop
border
issue
and
I
think
that
that
Lee
I
don't
know
what
you
think,
but
I
don't
know
that
we
really
need
to
talk
too
much
fun.
I!
Think
it's
just
like
the
lowering
the
disappearing
and
the
function
needs
to
change
so
that
it
actually
like
unbinds
the
the
arguments
inside
of
the
the
async
the
generated
async
block,
rather
than
having
them
be
outside
of
a
single
block.
A
B
B
A
B
A
Think
the
current
behavior
is
actually
what
I
would
expect
with
this
sniper.
You
know,
oh,
you
do
well.
The
only
reason
I
would
expect
it
is
that
when
you
get
to
these
weird
sort
of
edge
cases,
I
the
way
I
usually
think
about
how
to
figure
them
out
is
like,
let's
define
a
canonical,
be
sugar
into
the
simpler
thing
and
then
I
figure
out
what
would
happen
in
the
simpler
thing-
and
this
is
like
the
current
e
sugar
in
sort
of
the
canonical
simple
canonical
d
sugar.
B
A
A
B
A
B
B
B
So
I
think
I
think
the
motivating
example
for
me
is,
if
you
took
in
and
like
I,
don't
know
how
many
people
do
this
like
I
can
imagine
you
taking
in
an
argument.
That's
like
a
a
scope
to
end
when
your
function
is
over,
for
example,
and
then
you
binding
it
to
like
an
underscore
followed
by
name
their
pattern.
You
know
expecting
when
the
function,
which
is
that
thing
will
be
dropped
and
then
something
will
happen.
A
B
A
Think
about
a
little
more
right,
so
this
is
actually
what
I
expected
in
a
normal
FN
and
it's
actually
consistent
with
the
D
sugaring.
I
was
showing
you
because
that's
not
what
I
thought
so
the
reason
it's
consistent
with
this
D
sugaring
is:
if
pattern
is
underscore,
this
means
ignore
and
so
right
basically,
the
drop
is
when
X
goes
out
of
scope,
which
is
here
and
the
same
would
sort
of
be
true.
B
A
B
A
A
Know
it
openly
seems
hard.
The
only
reason
I
think
it
could
be
hard
has
to
do
with
like
complex
patterns
like
we
kind
of
do,
want
to
introduce
it.
Let
me
durable
the
Nardi
sugaring
right
right
and
that's
not
hard.
It's
just
like
a
high
genie.
Question
of
I
can
make
that
an
invisible
name
or
something
there's
probably
a
right
way
to
do
it.
We
can
sort
of
cheat
because
we're
in
the
here
itself
awesome.
A
B
B
A
A
A
B
A
B
A
A
A
B
Because
we
used
to
do
because
I
remember
when
talking
about
with
any,
we
used
to
do
this
whole
like
deferred
obligations,
thing
right,
where
we
would
save
up
all
of
the
lists
of
like
infiltrate
style,
stuff
that
needed
to
have
implemented
an
auto
trait
and
then
we
would
sort
of
calculate
assuming.
Those
are
true
are
those
true,
and
if
not,
we
would.
We
would
fail.
B
A
A
B
A
A
A
A
B
A
A
B
A
I'll
have
to
dig
into
this
okay
I'm,
pretty
sure.
Well
me
I
sort
of
want
to
do
that
in
an
item
payment.
Let's
come
back
to
it,
but
I'm
pretty
sure.
There's
a
problem
here
like
it
does
seem
kind
of
like
we
have
to
solve
these
problems
before
we
built
the
mirror.
So
there
must
be
something
exactly
where
that
code
is
I'm,
not
sure.
B
A
B
B
A
A
A
B
A
A
A
B
A
A
A
You
have
like
a
a
higher-ranked
type
somewhere
or
something.
Where
is
this?
Where
is
this
code
I'm
trying
to
remember?
Maybe
it's
what
this
witness
thing
is,
or
this
could
be
better
every
time,
I
dive
into
one
of
these
things,
I'm
like
why
don't
we
write
more
dogs
just
like
such
a
thing
that
should
have
been
done?
You're
in
there
we
go
generator
witness,
so
we
have.
Basically,
we
have
a
type,
that's
kind
of
like
representing
the
inside
and
it
has
sort
of
a
a
region.
A
A
A
A
A
A
A
A
B
We
had
one
specific
idea,
which
sort
of
addresses
a
really
common
case
here,
which
is
that
you
have
a
set
of
variables
that
are
only
live
across
exactly
one
yield
and
and
the
the
logic
for
for
unifying
the
storage,
for
those
seems
a
conceptually
much
much
simpler
than
doing
the
sort
of
general
problem
of
the
like
set
intersection
for
all
the
variables
that
are
alive
across.
You
know
a
set
of
yield
points
and
you
want
to
find
the
ones
for
which
those
sets
are
disjoint.
Yes,
so.
B
B
B
It
was
slightly
smarter
than
that,
unless
they're
moved
in
as
captures
right,
but
but
like
no,
no
two
variables
that
are
stored
across
a
yield
are
ever
stored
in,
like
in
the
same
space.
No
space
is
reused
right
and
so
I
want
to
get
like
a
sort
of
bare
minimum
amount
of
space
for
use,
so
that
when
you're
doing
something
stupid,
like
do
a
do
thing
a
then
do
thing
B
that
the
futures
for
a
and
B
aren't
always
on,
like
it's
not
strictly
additive.
B
B
When
he
did
this
before,
for
because
he
did
a
similar
thing
as
part
of
his
like
NR
vo
stuff,
although
he
did
it
in
on
a
much
like
larger
scale,
so
I
don't
know
if
it
would
be
I,
don't
I,
don't
know
how
how
comparatively
expensive
of
a
boom
beat.
But
but
he
gave
me
the
impression
that
it
was
prohibitively
expensive
to
do
that
calculation,
even
with
the
most
greedy
version
of
it.
I.