Aiming for ACSC2017.

Author: potanin

papers/ACSC2017/background.tex

@@ -0,0 +1,46 @@
+\section{Conclusion}\label{C:con}
+% Documentation of API is necessary.
+This work has explored refactoring and providing tool-support within the context of the Rust programming language. Utilizing existing infrastructure provided by the compiler, this work identifies extensions which help facilitate common automated refactorings. In a more general sense, this work attempts to build upon existing work done on refactoring by documenting specific decisions made in building a refactoring tool (which might normally only be encoded in the source code of an actual tool), and attempting to analyze the decisions made by others.
+
+% Rust provides some unique obstacles in providing automated refactorings...
+
+At the moment the provided tool supports renaming of local and global variables, fields, function arguments, structs, enum and functions (or methods). Beyond renaming, it also allows reification and elision of lifetime parameters for functions and methods and has preliminary support for inlining of local variables. These refactorings in particular highlight the idiosyncrasies of Rust, ensuring that the analyses performed here are some of the first of its kind. The complete limitations of these refactorings are not yet fully known, but there exists a current suite of tests to ensure that there are no obvious flaws in the approach. The presence of bugs in the compiler is a real problem to generality, but without real world use and more contribution to testing, finding these corner cases appears to be difficult.
+
+At the moment, Rust lacks significant refactoring tool-support and evidently requires more work particularly within the compiler to enable further, valuable progress. Although a preliminary tool has been provided, there are many avenues for continuing work and the hope is that this first investigation provides useful insight for future efforts. Understanding the required context and the necessary infrastructure has been a major part of this work. In particular, learning and understanding Rust has been incredibly challenging, as it introduces concepts rarely used elsewhere. Continuation of this work should allow greater focus on implementing a more difficult and comprehensive set of refactorings for Rust.
+
+\section{Appendix}\label{C:appen}
+\section{Eclipse refactorings}
+\begin{center}
+\begin{figure}
+\scalebox{0.9}{
+\begin{tabular}{ l | l | l }
+Rename &
+Move &
+Extract Method \\
+Extract Local Variable &
+Extract Constant &
+Inline \\
+Move Type to New File &
+Extract Superclass &
+Extract Interface \\
+Push Down &
+Pull Up &
+Extract Class \\ 
+Introduce Indirection &
+Introduce Factory &
+Introduce Parameter \\
+Encapsulate Field &
+Generalize Declared Type &
+Migrate JAR File \\
+Change Method Signature &
+Convert Anon. Class to Nested &
+Convert Local Variable to Field \\
+Use Supertype Where Possible &
+Introduce Parameter Object &
+Infer Generic Type Arguments
+\end{tabular}
+}
+\caption{List of refactorings supported by Eclipse}
+\label{Fig:eclipse}
+\end{figure}
+\end{center}

papers/ACSC2017/conclusion.tex

@@ -0,0 +1,300 @@
+%% This BibTeX bibliography file was created using BibDesk.
+%% http://www.cs.ucsd.edu/~mmccrack/bibdesk.html
+
+
+%% Created for neil at 2002-12-09 14:04:13 +1300 
+
+@misc{rustcore15,
+    author = "{The Rust Core Team}",
+    title = {{Announcing Rust 1.0 - The Rust Programming Language Blog}},
+    howpublished = {\url{http://blog.rust-lang.org/2015/05/15/Rust-1.0.html}},
+    year=2015,
+}
+
+@misc{rustbook15,
+    author = "{The Rust Community}",
+    title = {{The Rust programming Language}},
+    howpublished = {\url{https://doc.rust-lang.org/book/README.html}},
+    year=2015,
+}
+
+@misc{faq15,
+    author = "{The Rust Project Developers}",
+    title = {{The Rust Project FAQ}},
+    howpublished = {\url{https://doc.rust-lang.org/complement-project-faq.html}},
+    year=2015,
+}
+
+@misc{traitexample15,
+    author = "{The Rust Community}",
+    title = {{Traits}},
+    howpublished = {\url{http://rustbyexample.com/trait.html}},
+    year=2015,
+}
+
+@misc{docowner15,
+    author = "{The Rust Community}",
+    title = {{Ownership}},
+    howpublished = {\url{https://doc.rust-lang.org/book/ownership.html}},
+    year=2015,
+}
+
+@misc{docborrow15,
+    author = "{The Rust Community}",
+    title = {{Borrowing}},
+    howpublished = {\url{https://doc.rust-lang.org/book/references-and-borrowing.html}},
+    year=2015,
+}
+
+@misc{docmod15,
+    author = "{The Rust Community}",
+    title = {{Crates and Modules}},
+    howpublished = {\url{http://static.rust-lang.org/doc/master/book/crates-and-modules.html}},
+    year=2015,
+}
+
+@misc{openhub15,
+    author = "{Black Duck Open HUB}",
+    title = {{Rust (programming language)}},
+    howpublished = {\url{http://code.openhub.net/project?pid=&ipid=301463}},
+    year=2015,
+}
+
+@misc{makefile15,
+    author = "{The Rust Community}",
+    title = {{Rust Wiki - Compiler Snapshots}},
+    howpublished = {\url{https://github.com/rust-lang/rust-wiki-backup/blob/master/Note-compiler-snapshots.md}},
+    year=2015,
+}
+
+@misc{examplecrates15,
+    author = "{The Rust Community}",
+    title = {{Crates)}},
+    howpublished = {\url{http://rustbyexample.com/crates.html}},
+    year=2015,
+}
+
+@misc{driver15,
+    author = "{The Rust Community}",
+    title = {{librustc\_driver -- driver.rs}},
+    howpublished = {\url{https://github.com/rust-lang/rust/blob/master/src/librustc_driver/driver.rs}},
+    year=2015,
+}
+
+@misc{dxr15,
+    author = "{Github}",
+    title = {{Rust DXR plugin}},
+    howpublished = {\url{https://github.com/nrc/dxr/blob/rust5/dxr/plugins/rust/__init__.py}},
+    year=2015,
+}
+
+@misc{docpath15,
+    author = "{The Rust Community}",
+    title = {{Struct syntax::ast::Path}},
+    howpublished = {\url{http://doc.rust-lang.org/syntax/ast/struct.Path.html}},
+    year=2015,
+}
+
+@misc{doc15,
+    author = "{The Rust Community}",
+    title = {{Rust Documentation}},
+    howpublished = {\url{https://doc.rust-lang.org/}},
+    year=2015,
+}
+
+@misc{keep15,
+    author = {Keep, Daniel},
+    title = {{A Practical Intro to Macros in Rust 1.0}},
+    howpublished = {\url{https://danielkeep.github.io/practical-intro-to-macros.html}},
+    year=2015,
+}
+
+@article{foote1997big,
+  title={Big ball of mud},
+  author={Foote, Brian and Yoder, Joseph},
+  journal={Pattern languages of program design},
+  volume={4},
+  pages={654--692},
+  year={1997}
+}
+
+@phdthesis{opdyke1992refactoring,
+  title={Refactoring object-oriented frameworks},
+  author={Opdyke, William F},
+  year={1992},
+  school={University of Illinois at Urbana-Champaign}
+}
+
+@phdthesis{schafer2010specification,
+  title={Specification, Implementation and Verification of Refactorings},
+  author={Schafer, Max},
+  year={2010},
+  school={Oxford University}
+}
+
+@misc{gofmt15,
+    author = "{The Go Authors}",
+    title = {{Command gofmt}},
+    howpublished = {\url{https://golang.org/cmd/gofmt/}},
+    year=2015,
+}
+
+@misc{gofix11,
+    author = {Cox, Russ},
+    title = {{Introducing Gofix}},
+    howpublished = {\url{http://blog.golang.org/introducing-gofix}},
+    year=2011,
+}
+
+@misc{gorename15,
+    author = "{The Go Authors}",
+    title = {{Rename: check.go}},
+    howpublished = {\url{https://github.com/golang/tools/blob/master/refactor/rename/check.go}},
+    year=2015,
+}
+
+@phdthesis{stocker2010scala,
+  title={Scala refactoring},
+  author={Stocker, Mirko},
+  year={2010},
+  school={HSR Hochschule f{\"u}r Technik Rapperswil}
+}
+
+@misc{scala15,
+    author = "{Scala Refactoring}",
+    title = {{Scala Refactoring: Refactorings}},
+    howpublished = {\url{http://scala-refactoring.org/screenshots/}},
+    year=2015,
+}
+
+@phdthesis{brown2008tool,
+  title={Tool Support for Refactoring Haskell Programs},
+  author={Brown, Christopher Mark},
+  year={2008},
+  school={University of Kent}
+}
+
+@article{baumer2001integrating,
+  title={Integrating refactoring support into a Java development tool},
+  author={B{\"a}umer, Dirk and Gamma, Erich and Kiezun, Adam},
+  journal={OOPSLA’01 Companion},
+  year={2001}
+}
+
+@misc{widmer07,
+    author = {Widmer, Tobias},
+    title = {{Unleashing the Power of Refactoring}},
+    howpublished = {\url{http://www.eclipse.org/articles/article.php?file=Article-Unleashing-the-Power-of-Refactoring/index.html}},
+    year=2007,
+}
+
+@misc{cratesio15,
+    author = {Crates.io},
+    title = {{Cargo: The Rust Community's crate host}},
+    howpublished = {\url{https://crates.io/}},
+    year=2015,
+}
+
+@article{carruth2011clang,
+  title={{Clang MapReduce-Automatic C++ Refactoring at Google Scale}},
+  author={Carruth, C},
+  journal={Google Inc},
+  year={2011}
+}
+
+@misc{jetbrains15,
+    author = {Jetbrains},
+    title = {{Multi-language Refactorings}},
+    howpublished = {\url{https://www.jetbrains.com/idea/features/refactoring.html}},
+    year=2015,
+}
+
+@inproceedings{jemerov2008implementing,
+  title={{Implementing refactorings in IntelliJ IDEA}},
+  author={Jemerov, Dmitry},
+  booktitle={Proceedings of the 2nd Workshop on Refactoring Tools},
+  pages={13},
+  year={2008},
+  organization={ACM}
+}
+
+@book{fowler99,
+Year = {1999},
+Title = {Refactoring: Improving the Design of Existing Code},
+Address = {Reading, Massachusetts, USA},
+Publisher = {Addison-Wesley},
+Author = {Fowler, Martin and Beck, Kent}}
+
+@inproceedings{sculthorpe,
+  title={{The HERMIT in the Tree}},
+  author={Sculthorpe, Neil and Farmer, Andrew and Beck, Kent},
+  booktitle={{24th Symposium on Implementation and Application of Functional Languages, 2012}},
+  pages={86--103},
+  year={2013},
+  organization={Springer}
+}
+
+@misc{elisionrules,
+    author = "{The Rust Community}",
+    title = {{RFC - Lifetime elision}},
+    howpublished = {\url{https://github.com/rust-lang/rfcs/blob/master/text/0141-lifetime-elision.md}},
+    year=2014,
+}
+
+
+@misc{pwalton,
+    author = "{Walton, P. (Mozilla)}",
+    title = {{Why in the Rust language functions are not pure by default? -- Email}},
+    howpublished = {\url{https://mail.mozilla.org/pipermail/rust-dev/2013-January/002903.html}},
+    year=2013,
+}
+
+@inproceedings{effects,
+  title={{Lightweight polymorphic effects}},
+  author={Rytz, Lukas and Odersky, Martin and Philipp Haller},
+  booktitle={{Object-Oriented Programming -- ECOOP}},
+  pages={258--282},
+  year={2012},
+  organization={Springer}
+}
+
+@misc{inherit,
+    author = "{The Rust Community}",
+    title = {{RFC - Efficient code reuse}},
+    howpublished = {\url{https://github.com/rust-lang/rfcs/issues/349}},
+    year=2014,
+}
+
+@inproceedings{graph,
+  title={{Formalising behaviour preserving program transformations}},
+  author={Mens, Tom and Demeyer, Serge and Janssens, Dirk  },
+  booktitle={{International Conferenceon Graph Transformation (ICGT 2002)}},
+  pages={286--301},
+  year={2002},
+  organization={Springer-Verlag}
+}
+
+@article{aop,
+  title={The paradoxical success of aspect-oriented programming},
+  author={Steimann, Friedrich},
+  journal={ACM Sigplan Notices},
+  volume={41},
+  pages={481--497},
+  year={2006}
+}
+
+@misc{rrproject,
+    author = {Sam, Garming},
+    title = {{rust-refactor: Rust refactoring project}},
+    howpublished = {\url{https://github.com/GSam/rust-refactor}},
+    year=2015,
+}
+
+@misc{rfmt,
+    author = "{The Rust Community}",
+    title = "{rustfmt: Format Rust code}",
+    howpublished = {\url{https://github.com/nrc/rustfmt}},
+    year=2015,
+}
+
+

papers/ACSC2017/evaluation.tex

@@ -0,0 +1,48 @@
+\section{Introduction}\label{C:intro}
+This work is concerned with the analysis and implementation of tools to support the automated refactoring of Rust programs. The resulting refactoring tool built is written in Rust and available from Github under an MIT license \cite{rrproject}. The purpose of this chapter is to describe the overall work presented in this document and to begin to describe aspects of the motivation for pursuing this work. In Section \ref{S:rustintro} and Section \ref{S:refactorintro}, the context of the project is introduced with Rust and refactoring. In Section \ref{S:implemented}, the definite list of refactorings supported by the tool is described, along with a brief description of each. Lastly, in Section \ref{S:outline}, a summary of the subsequent chapters and the remaining document is given.
+
+%In Section \ref{S:contrib}, the contributions made by this work are described. 
+%In Chapter \ref{C:us} we explain how to use this document, and the \texttt{vuwproject} style. In Chapter \ref{C:ex} we say some things about \LaTeX, and in Chapter \ref{C:con} we give our conclusions.
+
+\subsection{Introducing the Rust programming language}\label{S:rustintro}
+
+% http://blog.rust-lang.org/2015/05/15/Rust-1.0.html
+
+The Rust programming language, as of May 2015, reached the 1.0 milestone \cite{rustcore15}. Backed by Mozilla and Mozilla Research, Rust is open source and generates a number of contributions from the community. As a modern memory-safe systems programming language, the aim for the language is to provide reliable and efficient systems by combining the performance of low level control, with the convenience and guarantees of higher level constructs. All of this is achieved without a garbage collector or runtime and allows interoperability with no overhead with C. Rust enforces an ownership system to restrict the duplication of references through borrowing and lifetimes, while still aiming for `zero cost abstractions'. Using these techniques, Rust prevents dangling pointers and a whole class of related issues concerning iterator invalidation, concurrency and more \cite{rustbook15}.
+
+Rust has been a number of years in the making, beginning as a side-project in 2006 \cite{faq15}, but only with this public 1.0 release has many of the standard library API stabilized. In order to further present itself as a stable and mature language, there is still another component which has yet to be adequately tackled: tooling. Developers commonly use a rich set of tools to simplify the task of building complex software with IDE, editors and debuggers. Such tools can improve productivity and providing tools specific to a language may help to encourage adoption.
+
+\subsection{The issue of refactoring}\label{S:refactorintro}
+Refactoring is the act of performing functionality preserving code transformation. Traditionally, these transformations needed to be performed manually, but in recent years, a number of tools to aid and automate refactorings have arisen in many programming languages such as Java or C++ \cite{brown2008tool}. Manual transformations, including editor search-and-replace are potentially prone to error and so performing tool-assisted refactoring which guarantees some measure of correctness can provide much greater confidence in changes.
+
+%\subsection{Contributions of this work}\label{S:contrib}
+%The main purpose of this work is to produce a proof-of-concept refactoring tool which utilizes existing infrastructure made available by the Rust compiler. With continuing expectations for change within the language and compiler and a number of API are still undergoing stabilization, a refactoring tool would prove beneficial for users at risk of changes breaking their code underneath them. In particular, API changes which convert global functions e.g. foo(A, B) to A.foo(B), to methods acting on an object are common and providing hopefully this work provides some insight into the necessary work to achieve such a refactoring. 
+
+%Exploring the necessary barriers to implementing a refactoring tool, proposals or implementation of extensions to the Rust compiler are brought forth and help to identify current shortcomings with providing refactoring tools for the Rust programming language and work necessary to improve the capability of Rust to support refactoring. Additionally, the current extent of the ability for the compiler to facilitate refactoring is evaluated and a number of internal or unstable API are assessed. The compile driver API which provides the ability for Rust code to invoke the compiler is a primary example of code which has seen little real world usage. The name resolution module within the compiler is another key example used in this work for performing refactoring, being used in a manner not originally intended or imagined despite providing part of the functionality required for implementing such a tool.
+
+% This work also attempts to provide initial evaluations as to the effectiveness and practicality of the current tool. Furthermore it aims to identify the most useful refactorings not currently supported by the tool and the most useful future changes required within the compiler for further iterations on the current work.
+
+%Implemented tool and refactorings
+\subsection{Contributions}\label{S:implemented}
+The main purpose of this work is to produce a proof-of-concept refactoring tool which utilizes existing infrastructure made available by the Rust compiler. The idea was to produce a tool which may be run to provide a set of refactorings, which may continue to be extended in the future. The list of implemented refactorings is as follows:
+
+%Although listed here, further details can be found on these refactorings in Chapters \ref{C:wd}, \ref{C:impl} and \ref{C:eval}.
+
+\begin{itemize}
+\item {\bfseries Renaming local and global variables} -- Variables declared within a function or method, or in a global namespace
+%\item {\bfseries Renaming global variables} -- Variables in a global namespace
+\item {\bfseries Renaming function arguments} -- Renaming local variables declared by a function or method signature
+\item {\bfseries Renaming fields} -- Struct-local members
+\item {\bfseries Renaming functions and methods} -- Statically or dynamically dispatched functions, and functions belonging to objects, including overridden methods
+\item {\bfseries Renaming structs} -- Custom data types declaring fields and methods
+\item {\bfseries Renaming enumerations} -- Enumerated data types declaring fields and methods
+\item {\bfseries Inlining local variables} -- Replacing usages of a local variable with its initializing expression
+\item {\bfseries Reification of lifetime parameters} -- Reintroducing inferred lifetimes for function and method signatures
+\item {\bfseries Elision of lifetime parameters} -- Removing lifetimes in function and method signatures that may be inferred (by the compiler)
+\end{itemize}
+
+%[WHAT MAKES IT HARD?] Namespaces, local and anonymous blocks, macros... 
+In performing this work, this project has helped understand difficulties with the Rust language and building refactoring tools, such as the hygienic macro-system. The first investigation of providing functionality for inlining a local variable in Rust has been presented here, as well as reification and elision of lifetime parameters (transformations whose natures are specific to Rust). As the user of an infrequently used compiler API, a number of general shortcomings have been identified with the overall approach, with several patches being submitted to the Rust compiler to help facilitate this work. It is the hope that some of these considerations are noted as the Rust compiler continues to evolve.
+
+\subsection{Document outline}\label{S:outline}
+In Chapter \ref{C:back}, we explore the prior related work and background knowledge required in understanding the work presented in this document. In Chapter \ref{C:wd}, we explain the general concepts of Rust refactoring, while in Chapter \ref{C:impl}, we discuss details of the implementation, focusing specifically on the tool itself and its associated design decisions. In Chapter \ref{C:eval}, we discuss opportunities for evaluation of the tool and the current extent of testing for refactorings provided by the tool and overall validity. In Chapter \ref{C:future}, we propose a number of further extensions to the tool, to the Rust compiler and in general, outline areas of future work while providing useful insights gained during the course of this work. Lastly, Chapter \ref{C:con} presents a summary, and gives conclusions about this work.