►
From YouTube: walk through rustc-integration PR 2020-04-15
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
B
B
A
So
yeah
I
look
through
the
comments
that
you
made
the
biggest
one
that
seems
like
you
should
do,
but
I
don't
know.
If
we
should
do
in
this
press,
maybe
even
a
precursor.
This
one
would
be
to
actually
rip
out
two
main
ball
and
all
the
like
old
stock,
some
stuff
that
were
used
for
the
old
integration
that
are
still
kind
of
playing
around
and
sort
of
embedded
into
some
things.
Alright,
so
it
seems.
B
A
The
main
goals
were
causes
clauses.
There's
there's
a
bunch
of
starts
that
like
sort
of
mimic
the
engine
or
I
guess
it
was
Chuck.
Ir
starts
that
look
like
they
can
be
just
removed
because
they
don't
seem
to
be
important
for
anything
else,
but
the
problem
is,
or
at
least
what
I'm
having
someone
right.
Now,
it's
sort
of
their
boundary
is
a
little
bit
difficult.
A
A
Yeah
so,
like,
like
I,
said,
I
think
it's
completely
doable
to
rip
them
out.
Like
I
said.
The
only
thing
with
the
current
sort
of
implementation
is
the
query
that
it's
passed
to
the
rust
scene.
Traits
crate
is
canonicalized
and
that's
canonicalized
in
the
chakra
fill
file,
but
it's
canonicalized
as
the
environment
yeah.
So,
let's
see.
B
B
B
A
I
mean
in
the
worst
part,
it's
all
about
moved
around
after
I
started
the
quest,
so
I've
had
to
refactor
moving
the
ground
thing
or
rebased
moving
around
things
three
times,
so
that's
fun,
fun
anyway.
So
this
is
most
part
where
things
start
with
a
query
start
and
it
mimics
or
you
know
it's
the
counterpart
to
the
fulfill,
but
file,
which
is
the
non
choc
trait
engine
and
then
so
the
main
part
or
what
actually
calls
out
into
the
brassy
traits
is.
If
you
go
down
and
select
where
possible,
with
the
evaluate
call
right.
B
So
the
context
for
folks
who
aren't
as
familiar
right
now,
the
way
we
did
the
integration
and
there's
this
treat
it
is
like
the
tree
engine
Russy
ones,
it's
Chuck.
It
lets
you
accumulate
things
that
have
to
be
true.
That's
what
registered
predicate
obligation
does.
This
has
to
be
proven
and
then
select
select.
All
our
error
will
say
everything
has
a
provable.
Our
also
should
report
in
error
and
select,
where
possible.
So
let's
go
try
to
prove
whatever
you
can
remove
it
from
the
list
of
stuff.
That
needs
to
be
done.
B
A
A
A
And
this
this
is
sort
of
we
were
talking
about
at
one
point
you
had
mentioned
that
there
used
to
be
I,
guess,
problems
with
actually
constructing
the
environments
or
that
that
had
to
be
resolved
and
that's
never
got
pulled
out.
So
that's
all
still
sort
of
here
and
then
it
calls
the
environment.
Query.
A
A
B
B
You
probably
do
want
to
do
this
pre
canonicalization,
because
I
think
at
least
I
think
we
sort
of
a
digression,
but
the
way
that
canonicalization
in
chalk
works
is.
It
only
replaces
infants
variables
with
boundary
regions
right,
but
canonicalization
in
rest
c
replaces
both
placeholders
in
the
end
bound
variables,
and,
if
you
think
about
it,
it
actually
makes
a
lot
of
sense,
because
the
goal
of
canonicalization
is
kind
of
to,
among
other
things,
avoid
doing
essentially
equivalent
work
twice.
B
So
if
you
have,
you
know
differences
that
don't
make
any
difference
to
be
up
to
the
Enzo.
You
want
to
try
to
eliminate
them
yeah,
it
won't
matter
if
we
had
two
placeholders
that
are
in
the
same
universities,
they're
both
in
the
room
universe
and
one
is
called
a-
is
called,
be
like
it
doesn't
make
a
difference,
so
we
would
prefer
to
normalize
them
to
consistent,
consistent
and
chalk,
of
course,
also
goes
further
and
then
does
universe
normalization.
B
B
That,
but
so
that
seems
to
imply,
we
would
prefer
to
create
the
rather
than
past
the
deaf
ID.
You
could
imagine,
passing
the
Deaf
idea
to
the
query,
along
with
the
goal
to
be
proven
and
then
constructed
a
new
environment,
but
that's
probably
not
the
ideal
thing,
because
we'd
rather
do
it
before
well.
I
didn't
quite
understand
his.
Why?
A
I
think
we
can
I've
been
playing
with
it
and
I
think
we
can
it's
sort
of
I'm
I'm
sort
of
D
generalizing,
some
of
the
code
right
now
to
make
it
more
amenable
to
moving
things
around,
but
I
think
we
can.
The
only
thing
is
there
are
some
things
that
weren't
showing
up
in
the
post:
canonicalization
trucks
that
were
that's
a
that
are
in
the
pre
canonicalized
form
like
they're
free
regions,
so
I
just
have
to.
D
B
B
A
B
A
B
Looks
like
ya
know
why
it
wouldn't
show
up
there,
because
these
dependents,
that
we
pass
them
through
I
think
they
should
be
eventually
replaced
with
a
placeholder
actually
like
rusty.
Has
this
distinction
enough?
You
know
placeholder,
like
things
that
the
user
declared
versus
ones
that
came
out
of
higher
ranks.
A
A
B
D
B
A
D
A
B
Almost
that's
where
you
were
was
that's
where
you
were
suggesting
I
was
just
gonna
say
that
we
could.
We
can
basically
just
send
the
canonical
obligation
through
to
this
query,
as
is
it's
kind
of
Olive
can
say
this
evaluate
goal
like
all
in
rusty
terms
and
adds
to
the
other
side.
We
instantiate
it.
Now
we
have
an
entrance
context,
we
have
a
query
and
then
we
can
run
this
code
only
producing
chocolates
trucks
and
there's
no
more
conical
ization,
because
that's
all
like
on
the
chalk
side.
Essentially,
oh
I,
see
now
whether
this
this.
B
C
D
B
A
B
B
A
B
Okay,
yeah,
so
the
other
way
we
could
have
do
this
is
we
could
create
our
cool
prints
context.
You
could
stand
check
this
canonical
thing
in
it.
You
could
build
a
chalk
term.
This,
like
you,
could
even
create
a
chocolate
inference.
Context
as
well
build
a
truck
term
that
is
equivalent
so,
where
there's
an
infant's
variable
and
press
C,
we
make
anything.
Scribble
and
Chuck
Britz
nipple
run.
B
B
B
E
D
B
B
B
B
B
A
B
B
B
A
B
Do
that
actually?
Well,
we
can
come
back
resisting
talking
about
the
environment.
I
think
we
should
probably
work
more
towards
like
the
goal
was
that
rusty
types
have
a
counterpart
and
vice
versa,
and
there's
like
I'm,
just
a
simple
math
between
them.
The
other
words
that
the
actual
intern
is
a
rescue
type.
B
Which
is
that
we
could
like
we
have
to
look
at
what
exactly
the
chunk
environment
is
that
we're
dealing
with
slightly
different
and
the
rusty
one
cuz.
It's
got
a
little
bit
more
of
implied
bone
structure
and
stuff,
but
if
we
can
express
those
in
rusty
predicates,
then
we
could
build
the
chalk,
one
and
rusty
terms
right
and
then
lower
that
come
on
close
it
with
Rusty's,
clown,
cleanser
and
then
lower
it,
and
we
only
have
one
concept
of
lowering
at
least
receiving
prime
yeah.
B
A
A
B
B
B
I
think
we
want
to
add
some
time
too.
Chalk
and
I
was
gonna.
Verify
I
was
going
to
ping
you
about
this
as
a
possible
topic
and
they've
got
some
instructions
for
what,
because,
among
other
things,
Chuck's
notion
of
type
equality
is
actually
wrong
like
it
doesn't
handle
higher
rank
things
entirely
correctly
and
I
think
the
only
way
to
do
it
is
by
having
creating
subtyping
code.
B
It
comes
out
because
of
those
functions
and
variants
and
variants,
but
so
that
I
think
will
end
up.
Porting
closure
kind,
yeah.
Well,
we'll
figure
it
out,
I
kind
of
think
closure
coin
and
forget
how
I
want
to
deal
with
that.
So
that
tells
you
what
whether
our
closure
is
f,
an
earthen
mute
earthen
once
and
it's
something
we
don't
know
right
away,
but
we
figured
out
later
and
I.
B
B
Object
safe.
Might
you
might
end
up
just
to
keep
ourselves
saying
I
could
imagine
adding
that
as
a
flag
to
trade
item
or
something
like
that,
keeping
it
so
that
rusty
so
much
to
do
that
computation?
It
just
tells
us
yes
or
no.
It
is
not
too
safe
or
it's
not,
but
if
to
look
this
I
think
yeah.
Those
rules
are
a
little
bit
tricky
anyway.
Okay,
it's
fine
like
this.
For
now,
right.
A
A
A
A
But
be
nice
but
yeah,
so
maybe
we
can
come
back.
There
collect
bomb
drivers
after
we
just
go
through
the
lowering,
because
I
think
the
well.
Our
input
is
is
fairly
simple,
but
I
think
we
should
maybe
discuss
to
make
sure
we
so
projection
predicate
more
or
less
the
same
thing
make
sense.
Poly
production.
A
A
A
A
Yeah,
maybe
if
you
want
to
go
down
to
that
yeah,
so
this
is
where
it's
sort
of
yeah.
These
are
similar
cut
that
we
might
know.
This
is
probably
the
biggest
one
or
the
most
important
in
communication
to
talk
about
is
lowering
for
ties
so
right
now
these
are
more
or
less
one
to
one
where
each
tie
has
a
supper,
either
substitution
and
then
they're
they're
sort
of
defined
by
the
brought
stuff
ID.
B
B
E
B
A
B
B
We
won't
have
a
chance
to
substitute
it
because
it's
free
in
the
cold.
This
is
kind
of
the
case,
we're
not
ordinarily,
we
would
substitute
it
because
we'll
have
been
pulling
some
type
from
a
definition
and
that
we
can
substitute
as
parameters
remember,
but
here
where
it
appears
free
and
the
goal
I
think
we
would
encounter
it
I
think
we
would
want
to
translate
it
to
a
place
holder
in
the
route
universe.
B
A
B
A
Maybe
side
note
we
should
probably
go
through
and
make
a
list
of
tests
that
we
need
to
cover-
maybe
not
just
for
this,
but
in
the
future
is
right
now
and
I
I
feel
like
there's,
probably
a
and
some
overarching
theme
for
what
each
test
is
supposed
to
test.
But
it's
not
super
flex
Ocean.
That
region
is
similar
to
tie
and
that
a
lot
of
things
are
well
now.
The
Regents
are
complicated,
so
maybe
the
big
thing
is
the
we
early
bound
versus
they
found
the
discussion.
A
So
early
bounds,
we
like
params,
we
sort
of
already
handle
lists
farther
up
when
we
had
the
concept,
arounds
and
so
it'll
panic
here,
because
it
shouldn't
show
up
late
bounds.
We
already
have
an
index
on
that
and
I
guess
yeah,
and
it's
also
important
and
we'll
cover
this
later.
The
early
Dawn's
are
actually
converted
to
Lake
balance.
You
actually
sort
of
keep
track
of
an
index.
B
A
That's
not
quite
right,
you
know
so
collect
on
bars,
so
we
sort
of
have
to
do
bound
bar
a
collection
in
two
passes,
so
the
first
pass.
We
actually
collect
them,
but
in
the
second
passed
we
substitute
named
bars
for
indexed
bars
and
we
sort
of
have
to
do
that
in
the
second
pass,
so
that
the
index
II
and
in
she's
that
we
substitute
or
after
all,
of
the
sort
of
non
names
once.
B
B
A
A
B
A
It's
the
other
way
around
the
anonymous
ones,
stay
the
same.
The
name
ones
came
after
I,
don't
know
if
it
matters
too
much
the
way.
It's
just
I,
guess
more
simple
to
do
it.
This
way,
just
looking
straight
ahead
of
time,
and
then
this
is
found,
Graham
substitute
ER,
and
so
this
is
separately.
So
this
is
not
in
the
collecting
bound
bars.
This
is
when,
before
we
actually
lower
anything,
we
substitute
the
parameters.
B
A
B
A
B
Maybe
I
could
have
mentioned
that
to
you
before
him
and
if
you
use
this
helper,
this
one
kind
of
maybe
doesn't
give
you
everything
you
might
want.
The
replaced
late
Brown
region's
function
also
gives
you
back
a
map
from
what
was
the
boundary
j'en.
What
was
the
region
we
created
for
that?
Oh,
maybe
you
don't
need
that
map.
Actually,
the
only
reason
you
might
want
that
map-
I,
guess:
okay,
so
the
lazy
persons
version
of
this
code,
I
guess
would
be
that
you
would
call
the
anonymize
area.
B
You
would
call
anonymize
lake
bound
regions
or
whatever
this
needs
to
be
a
bun
your
teeth,
and
then
you
would
that
would
give
you
back
something
with
all
BR
nuns.
Then
you
have
to
call
probably
this
is
why
I
say
lazy.
That's
fishing!
There's
some
function.
Maybe
it's
not
called
calendar
against
which
will
count
how
many
late
dawn
regions
there
are
and
tell
you,
because
you
kind
of
need
that
number
right.
That.
D
B
B
A
A
A
A
B
B
B
B
B
B
There
was
only
a
pyramid
function,
items
which
you
probably
are
just
not
getting
interact
with
at
all,
so
you
can
probably
just
delete
this
substitute
prims
word
or
make
it
much
simpler
because
also
bound
bars
for
item.
Like
could
return
to
you,
the
list
of
parameter
kinds
right,
it's
creating
all
that
or
we
could
get
it
from
other
places
that.