►
From YouTube: Rust support for KDevelop — Emma Gospodinova
Description
Rust was voted “most loved” language by developers for the second year in a row in the Stack Overflow developer survey. There have been projects made using Rust on everything from operating systems to game engines for Minecraft-like games. Despite this, IDE support is still very limited.
As my Google Summer of Code project, I worked on a Rust plug-in for the KDevelop IDE which aimed to support most standard IDE features such as semantic highlighting, code completion, project management and debugging. I will go through the challenges of integrating language support in an existing IDE and talk about how adding semantic highlighting was one line of code and getting debugging to work took less than 10 minutes.
A
Hi
everyone
I'm
happier
here
to
see,
see
the
talk.
So,
let's,
let's,
let's
dive
straight
in
so
a
few
words
about
me.
So
I
am
a
third-year
undergraduate
student
at
Imperial,
College
London
I
got
into
rust,
well
I
I,
initially
found
out
about
rust
a
couple
of
years
ago,
but
I
got
more
into
it
earlier
this
year
and
I
decided
to
do
a
G
sock
project
working
on
adding
language
support
in
K,
develop
for
rust,
so
yeah
so
a
bit
about
the
project.
A
So
the
main,
the
main
sort
of
part
of
the
project
is
a
library
that
I
that
I
did,
which
is
essentially
kind
of
takes
information
from
from
the
russ
compiler
from
lip
syntax
and
then
presents
it
to
presents
it
to
k,
develop
work
where
I
hooked
up
things
and
yeah.
Basically,
you'll
you'll
see
a
bit
later,
like
the
a
few
demos
from
from
k
develop.
A
Essentially,
K
develop,
expects
a
lot
of
internal
structures
to
be
to
be
built
and
the
K
develop
core
code
as
a
not
not
the
language
plug-in,
but
the
core
of
K
develop
does
a
lot
a
lot
of
things
for
you,
so
things
like
semantic,
highlighting
renaming
declarations.
Finding
usages
that
kind
of
thing,
like
that's
all
done
for
that's
all
done
for
you
by
K,
develop
as
long
as
the
language
plug-in,
builds
these
internal
data
structures.
A
So
what
is
what
is
ASD
Redux?
So
it's
it's
a
self-contained
library,
it's
somewhat
similar
to
Lipsy
lying.
If
you've
seen
that
or
see,
pythons
ast
library,
it's
it's
a
bit
lower
level
than
RLS.
So
with
our
LS,
you
would
ask
ask
the
language
server,
something
like
Oh.
Tell
me
all
the
declarations
for
this
particular
symbol
or
tell
me
all
the
usages
for
this
particular
symbol
and
RLS
would
give
all
those
to
you
here.
It's
more
like.
Oh
here's,
a
bunch
of
symbols.
You
figure
out
what
to
do.
A
It
provides
a
view
of
the
abstract
syntax
tree
of
the
of
the
code,
and
it
sort
of
it
exposes
this
as
a
C
API,
and
it
hides
the
details
of
working
with
Lipstein
syntax,
so
yeah
at
the
moment,
it's
using
lip
syntax
as
a
sort
of
platform
to
build
on
in
the
future,
I
might
I'm
looking
into
getting
more
information
from
the
rest
compiler
and
exposing
that
in
a
meaningful
way
as
well.
So
how
does
this
interact
with
Kay
develop
so
Kay
develop
essentially
expects
these
internal
data
structures
to
be
built.
A
Let's,
let's
go
on
and
see
some
of
the
things
that
you
can
do
in
kata
valve.
So,
like
I
said.
Essentially
what
what
happens
is
you
go
through
the
ast
for
each
node?
You
figure
out
like
if
it's
something
like
a
function,
a
struct,
an
ample
or
anything
else.
You
build
the
corresponding
data
structure
in
kata
bell
and
you're
done.
You
get
a
lot
of
things
for
free
at
that
point
so
stuff
like
semantics,
highlighting
that's.
Basically,
a
single
function
call
and
voila
Kay,
develop
figures
out
the
rest
for
you.
So
let
there
be
color.
A
A
With
regards
to
building
and
debugging
straight
from
the
ID
again
Kay,
develop
has
support
for
gdb
and
ll
DB,
so
it
was
essentially
a
matter
of
getting
those
hooked
up
to
work
with
rust,
executables,
and
this
as
well
works
straight
out
of
the
box.
You
can,
you
can
run
your
code
directly
from
from
Kay
develop.
So
same
thing,
you
can,
you
can
add
breakpoints,
you
can
see
all
of
the
all
of
the
variables
all
their
current
values,
step
through
the
program,
etc,
etc.
All
the
regular
things
you
you
would
want
to
do
when
debugging.
A
So
yeah,
but
I
am
trying
to
work
around
that
by
sort
of
doing
what
a
lot
of
other
language
plugins
do,
which
is
exposing
like
building,
essentially
a
the
full
or
expanding
the
full
source
code
of
the
standard
library
and
then
Kay
develop,
can
just
parse
that
directly
or
yeah
and
in
the
future,
I'm
looking
to
do
the
same
thing
for
other
libraries.
So
cargo
has
this
great
thing,
which
is
it
downloads,
the
libraries
it
checks
them
out
from
get,
and
you
can
essentially
find
all
the
metadata
all
the
information
you
need
to.
A
A
So
there's
a
lot
of
work
that
can
be
done
there,
so
things
like
building
straight
it
straight
like
essentially
using
the
russ
compiler
to
build
and
extract
any
errors
that
are
that
are
found
in
the
code
and
expose
those
there
can
be
integration
with
RLS
in
the
future.
So
yeah
stuff
like
that,
there's
there's
a
lot
a
lot
that
can
be
done
in
this.
In
this
regard.
A
So
thing
Thank
You
thing
thanks
to
everyone,
and
thank
you
all
for
for
listening
so
with
that
I
I
just
want
to
say
if
you
want
to
try
out
k,
develop,
come
and
see
me
at
some
point
today
and
I
can
explain
how
you
can
do
that,
because
at
the
moment
it's
based
on
the
current
masters.
So
building
everything
from
scratch
might
be
a
bit
not
straightforward.
So
yeah
come
and
see
me
at
any
point,
I'm
happy
to
help
ya.
B
B
A
Yeah,
so
at
the
moment,
I
am
trying
to
keep
it
up
to
date
and
the
way
I've
set
it
up
so
that
I
can
figure
out
when
something
breaks
is
I,
have
a
daily
build
on
Travis
setup.
So
if
anything
breaks
overnight
like
I
get
an
email
instantly,
so
I've
been
trying
to
keep
up
with
those.
There
haven't
been
that
many
of
those
so
far
so
yeah.
B
A
That's
one
thing
that
I'm
trying
to
decide
on
how
to
do
exactly
because
K
develop,
does
name
resolution
for
you,
but
obviously,
if
like,
if
I
want
it
to
be
sort
of
this
agnostic
library
that
can
be
used
in
other
projects,
then
I
would
have
to
do
name
resolution
within
the
rest
library.
So
at
the
moment,
I'm
using
K
develops
features
to
do
name
resolution
but
I'm
looking
into
moving
that
over
into
into
ASU
Redux.
Oh.
A
Yeah
lips,
syntax
I'm,
guessing
because
it
was
sort
of
built
at
a
point
where
Russ
didn't
really
have
the
error
handling
features.
It
does
today.
So
lip
syntax
panics
on
quite
a
few
things
like
unexpected
tokens.
So,
for
example,
if
there
is
a
backslash
somewhere,
then
it
just
panics
so
stuff
like
that.
I
had
to
try
to
work
around
that.
So
I
do
at
the
moment.
I
do
the
same
thing
as
the
rest
compiler,
which
is
I
spin
it
up
in
a
new
thread
and
wait
to
see
what
happens.
A
A
Think
that
I
quite
appreciated
the
K
develop,
does
a
lot
of
these
things
for
you.
So
I've
worked
with
K
develop
in
the
past,
so
I
sort
of
knew
about
this,
and
that's
one
of
my
main
motivations
of
choosing
to
do
it
this
way,
rather
than
using
our
last,
because
the
way
that
the
way
that
K
develops
sort
of
handles
these
these
things
behind
the
scenes
like
if,
if
I
had
decided
to
do
with
RLS,
then
if
I
decided
to
work
with
her
LS
I
would
essentially
have
had
to
reimplemented.
A
On,
like
its
kind
of
it,
works
with
its
own
data
structures
and
at
the
same
time,
it's
based
on
Kate,
so
things
like
the
syntax
highlighting
is
actually
implemented
in
Kate
and
Kate.
Develop
only
says
okay
well,
for
these
ranges
like
do
like
do
this
sort
of
colouring
or
whatever
and
yeah
like.
Basically,
if,
if
I
decided
to
use
our
less,
all
that
code
would
become
obsolete,
so
everything
would
have
to
be
reimplemented
on
top
of
the
language
server
protocol,
so
I
think
that
would
have
been
quite
a
bit
more
work.
A
A
So
the
google
Summer
of
Code
program
basically
works,
like
you
submit
a
proposal
and
if
there's
interest
from
the
organization
to
do
that
to
do
that
project,
then
they
find
mentors
for
you.
So
I
was
working
with
Kevin
funk
who
who
works
on
the
C++
plugin
inkay
develop
and
yeah
like
he.
He
basically
helped
me
a
bit
through
like
getting
this
like
set
up
and
that
kind
of
thing.
A
A
A
A
A
I,
don't
think
it
will
be
impossible.
I
think
that
would
make
the
RLS
a
lot
more
useful
for
K
develop,
for
example,
so
yeah
like
at
the
moment,
RLS
sort
of
implements
the
language
server
protocol,
which
doesn't
really
have
any
options
for
exposing
the
abstract
syntax
tree.
For
example,
there
are
other
similar
protocols.
A
I
I
was
pointed
to
one
over
the
summer,
but
I
I
I,
don't
have
it
off
the
top
of
my
head,
which,
like
which
language
had
that.
But
there
was
a
sort
of
similar
language
server
type
software,
which
exposed
more
more
information
about
the
structure
of
the
code
to
the
ID.
So
if
RLS
had
a
feature
features
like,
then
it
would
be
very
useful
for
integrating
with.