Merge pull request #127 from immunant/feature/nightly-2019-06-20

Roll nightly version to 2019-06-22 to support va_copy

Author: rinon

README.md

@@ -6,7 +6,7 @@
 [azure]: https://dev.azure.com/immunant/c2rust/_build/latest?definitionId=1&branchName=master
 [Latest Version]: https://img.shields.io/crates/v/c2rust.svg
 [crates.io]: https://crates.io/crates/c2rust
-[Rustc Version]: https://img.shields.io/badge/rustc-nightly--2019--04--12-lightgrey.svg "Rustc nightly-2019-04-12"
+[Rustc Version]: https://img.shields.io/badge/rustc-nightly--2019--04--12-lightgrey.svg "Rustc nightly-2019-06-20"
 
 C2Rust helps you migrate C99-compliant code to Rust. The [translator](c2rust-transpile) (or transpiler) produces unsafe code Rust code that closely mirrors the input C code. The primary goal of the translator is to preserve functionality; test suites should continue to pass after translation. Generating safe and idiomatic Rust code from C ultimately requires manual effort. However, we are building a scriptable [refactoring tool](c2rust-refactor) that reduces the tedium of doing so. You can also [cross-check](cross-checks) the translated code against the original ([tutorial](docs/cross-check-tutorial.md)).
 
@@ -51,22 +51,22 @@ Finally, a rust installation with [Rustup](https://rustup.rs/) is required on al
 
 ### Installing from crates.io
 
-    cargo +nightly-2019-04-12 install c2rust
+    cargo +nightly-2019-06-20 install c2rust
 
 On OS X with Homebrew LLVM, you need to point the build system at the LLVM installation as follows:
 
-    LLVM_CONFIG_PATH=/usr/local/opt/llvm/bin/llvm-config cargo +nightly-2019-04-12 install c2rust
+    LLVM_CONFIG_PATH=/usr/local/opt/llvm/bin/llvm-config cargo +nightly-2019-06-20 install c2rust
 
 On Linux with Linuxbrew LLVM, you need to point the build system at the LLVM installation as follows:
 
-    LLVM_CONFIG_PATH=/home/linuxbrew/.linuxbrew/opt/llvm/bin/llvm-config cargo +nightly-2019-04-12 install c2rust    
+    LLVM_CONFIG_PATH=/home/linuxbrew/.linuxbrew/opt/llvm/bin/llvm-config cargo +nightly-2019-06-20 install c2rust    
 
 Note: adjust `LLVM_CONFIG_PATH` accordingly if Linuxbrew was installed to your home directory.
 
 On Gentoo, you need to point the build system to the location of `libclang.so` 
   and `llvm-config` as follows:
 
-    LLVM_CONFIG_PATH=/path/to/llvm-config LIBCLANG_PATH=/path/to/libclang.so cargo +nightly-2019-04-12 install c2rust 
+    LLVM_CONFIG_PATH=/path/to/llvm-config LIBCLANG_PATH=/path/to/libclang.so cargo +nightly-2019-06-20 install c2rust 
 
 
 If you have trouble with building and installing, or want to build from the latest master, the [developer docs](docs/README-developers.md#building-with-system-llvm-libraries) provide more details on the build system.

c2rust-ast-builder/src/builder.rs

@@ -2,12 +2,12 @@
 use rustc::hir;
 use rustc_target::spec::abi::{self, Abi};
 use std::rc::Rc;
+use std::str;
 use syntax::ast::*;
 use syntax::attr::mk_attr_inner;
-use syntax::parse::token::{self, DelimToken, Token};
+use syntax::parse::token::{self, DelimToken, TokenKind, Token};
 use syntax::ptr::P;
 use syntax::source_map::{dummy_spanned, Span, Spanned, DUMMY_SP};
-use syntax::symbol::keywords;
 use syntax::tokenstream::{TokenStream, TokenStreamBuilder, TokenTree};
 use syntax::ThinVec;
 
@@ -167,6 +167,16 @@ impl<'a> Make<LitIntType> for UintTy {
     }
 }
 
+impl Make<Lit> for hir::Lit {
+    fn make(self, _mk: &Builder) -> Lit {
+        Lit {
+            token: self.node.to_lit_token(),
+            node: self.node,
+            span: self.span,
+        }
+    }
+}
+
 impl<I: Make<Ident>> Make<PathSegment> for I {
     fn make(self, mk: &Builder) -> PathSegment {
         PathSegment {
@@ -200,7 +210,7 @@ impl Make<TokenStream> for Vec<TokenTree> {
 
 impl Make<TokenTree> for Token {
     fn make(self, _mk: &Builder) -> TokenTree {
-        TokenTree::Token(DUMMY_SP, self)
+        TokenTree::Token(self)
     }
 }
 
@@ -357,8 +367,11 @@ impl Builder {
             style: AttrStyle::Outer,
             path: key,
             tokens: vec![
-                Token::Eq,
-                Token::Literal(token::Lit::Str_(value.into_symbol()), None),
+                TokenTree::token(token::Eq, DUMMY_SP),
+                TokenTree::token(
+                    TokenKind::Literal(token::Lit::new(token::LitKind::Str, value.into_symbol(), None)),
+                    DUMMY_SP
+                )
             ]
             .into_iter()
             .collect(),
@@ -401,21 +414,22 @@ impl Builder {
 
         let tokens: TokenStream = {
             let mut builder = TokenStreamBuilder::new();
-            builder.push(Token::OpenDelim(DelimToken::Paren));
+            builder.push(TokenTree::token(TokenKind::OpenDelim(DelimToken::Paren), DUMMY_SP));
 
             let mut is_first = true;
             for argument in arguments {
                 if is_first {
                     is_first = false;
                 } else {
-                    builder.push(Token::Comma);
+                    builder.push(TokenTree::token(TokenKind::Comma, DUMMY_SP));
                 }
 
                 let argument: Ident = argument.make(&self);
-                builder.push(Token::from_ast_ident(argument));
+                let token_kind = TokenKind::Ident(argument.name, argument.is_raw_guess());
+                builder.push(TokenTree::token(token_kind, DUMMY_SP));
             }
 
-            builder.push(Token::CloseDelim(DelimToken::Paren));
+            builder.push(TokenTree::token(TokenKind::CloseDelim(DelimToken::Paren), DUMMY_SP));
             builder.build()
         };
 
@@ -470,7 +484,7 @@ impl Builder {
         AngleBracketedArgs {
             span: self.span,
             args: args,
-            bindings: vec![],
+            constraints: vec![],
         }
     }
 
@@ -504,20 +518,20 @@ impl Builder {
         path.make(&self)
     }
 
-    pub fn abs_path<Pa>(self, path: Pa) -> Path
-    where
-        Pa: Make<Path>,
-    {
-        let mut p = path.make(&self);
-        if !p
-            .segments
-            .get(0)
-            .map_or(false, |s| s.ident.name == keywords::Crate.name())
-        {
-            p.segments.insert(0, keywords::Crate.ident().make(&self));
-        }
-        p
-    }
+//    pub fn abs_path<Pa>(self, path: Pa) -> Path
+//    where
+//        Pa: Make<Path>,
+//    {
+//        let mut p = path.make(&self);
+//        if !p
+//            .segments
+//            .get(0)
+//            .map_or(false, |s| s.ident.name == kw::Crate)
+//        {
+//            p.segments.insert(0, kw::Crate.ident().make(&self));
+//        }
+//        p
+//    }
 
     pub fn anon_const<E>(self, expr: E) -> AnonConst
     where
@@ -941,55 +955,56 @@ impl Builder {
         let body = body.make(&self);
         Arm {
             attrs: self.attrs,
-            pats: pats,
+            pats,
             guard,
             body,
+            span: DUMMY_SP,
         }
     }
 
     // Literals
 
     pub fn bytestr_lit(self, s: Vec<u8>) -> Lit {
-        Lit {
-            node: LitKind::ByteStr(Rc::new(s)),
-            span: self.span,
-        }
+        Lit::from_lit_kind(
+            LitKind::ByteStr(Rc::new(s)),
+            self.span
+        )
     }
 
     pub fn str_lit<S>(self, s: S) -> Lit
     where
         S: IntoSymbol,
     {
         let s = s.into_symbol();
-        Lit {
-            node: LitKind::Str(s, StrStyle::Cooked),
-            span: self.span,
-        }
+        Lit::from_lit_kind(
+            LitKind::Str(s, StrStyle::Cooked),
+            self.span
+        )
     }
 
     pub fn byte_lit(self, b: u8) -> Lit {
-        Lit {
-            node: LitKind::Byte(b),
-            span: self.span,
-        }
+        Lit::from_lit_kind(
+            LitKind::Byte(b),
+            self.span
+        )
     }
 
     pub fn char_lit(self, c: char) -> Lit {
-        Lit {
-            node: LitKind::Char(c),
-            span: self.span,
-        }
+        Lit::from_lit_kind(
+            LitKind::Char(c),
+            self.span
+        )
     }
 
     pub fn int_lit<T>(self, i: u128, ty: T) -> Lit
     where
         T: Make<LitIntType>,
     {
         let ty = ty.make(&self);
-        Lit {
-            node: LitKind::Int(i, ty),
-            span: self.span,
-        }
+        Lit::from_lit_kind(
+            LitKind::Int(i, ty),
+            self.span
+        )
     }
 
     pub fn float_lit<S, T>(self, s: S, ty: T) -> Lit
@@ -999,28 +1014,28 @@ impl Builder {
     {
         let s = s.into_symbol();
         let ty = ty.make(&self);
-        Lit {
-            node: LitKind::Float(s, ty),
-            span: self.span,
-        }
+        Lit::from_lit_kind(
+            LitKind::Float(s, ty),
+            self.span
+        )
     }
 
     pub fn float_unsuffixed_lit<S>(self, s: S) -> Lit
     where
         S: IntoSymbol,
     {
         let s = s.into_symbol();
-        Lit {
-            node: LitKind::FloatUnsuffixed(s),
-            span: self.span,
-        }
+        Lit::from_lit_kind(
+            LitKind::FloatUnsuffixed(s),
+            self.span
+        )
     }
 
     pub fn bool_lit(self, b: bool) -> Lit {
-        Lit {
-            node: LitKind::Bool(b),
-            span: self.span,
-        }
+        Lit::from_lit_kind(
+            LitKind::Bool(b),
+            self.span
+        )
     }
 
     pub fn ifte_expr<C, T, E>(self, cond: C, then_case: T, else_case: Option<E>) -> P<Expr>
@@ -1605,7 +1620,7 @@ impl Builder {
         let mac = mac.make(&self);
         let kind = ItemKind::Mac(mac);
         Self::item(
-            keywords::Invalid.ident(),
+            Ident::invalid(),
             self.attrs,
             self.vis,
             self.span,
@@ -1659,7 +1674,7 @@ impl Builder {
     {
         let ty = ty.make(&self);
         Self::item(
-            keywords::Invalid.ident(),
+            Ident::invalid(),
             self.attrs,
             self.vis,
             self.span,
@@ -1709,7 +1724,7 @@ impl Builder {
             kind: UseTreeKind::Simple(rename, DUMMY_NODE_ID, DUMMY_NODE_ID),
         };
         Self::item(
-            keywords::Invalid.ident(),
+            Ident::invalid(),
             self.attrs,
             self.vis,
             self.span,
@@ -1743,7 +1758,7 @@ impl Builder {
             kind: UseTreeKind::Nested(inner_trees),
         };
         Self::item(
-            keywords::Invalid.ident(),
+            Ident::invalid(),
             self.attrs,
             self.vis,
             self.span,
@@ -1758,7 +1773,7 @@ impl Builder {
             items,
         };
         Self::item(
-            keywords::Invalid.ident(),
+            Ident::invalid(),
             self.attrs,
             self.vis,
             self.span,
@@ -1800,7 +1815,7 @@ impl Builder {
         let mac = mac.make(&self);
         let kind = ImplItemKind::Macro(mac);
         Self::impl_item_(
-            keywords::Invalid.ident(),
+            Ident::invalid(),
             self.attrs,
             self.vis,
             Defaultness::Final,
@@ -1840,7 +1855,7 @@ impl Builder {
         let mac = mac.make(&self);
         let kind = TraitItemKind::Macro(mac);
         Self::trait_item_(
-            keywords::Invalid.ident(),
+            Ident::invalid(),
             self.attrs,
             self.generics,
             self.span,
@@ -1893,14 +1908,13 @@ impl Builder {
     {
         let name = name.make(&self);
         let ty = ty.make(&self);
-        let is_mut = self.mutbl == Mutability::Mutable;
         Self::foreign_item(
             name,
             self.attrs,
             self.vis,
             self.span,
             self.id,
-            ForeignItemKind::Static(ty, is_mut),
+            ForeignItemKind::Static(ty, self.mutbl),
         )
     }
 
@@ -1926,7 +1940,7 @@ impl Builder {
         let mac = mac.make(&self);
         let kind = ForeignItemKind::Macro(mac);
         Self::foreign_item(
-            keywords::Invalid.ident(),
+            Ident::invalid(),
             self.attrs,
             self.vis,
             self.span,
@@ -2017,6 +2031,7 @@ impl Builder {
         let ty = ty.make(&self);
         let pat = pat.make(&self);
         Arg {
+            attrs: ThinVec::new(),
             ty: ty,
             pat: pat,
             id: self.id,
@@ -2029,7 +2044,8 @@ impl Builder {
     {
         let eself = dummy_spanned(kind.make(&self));
         let ident = "self".make(&self);
-        Arg::from_self(eself, ident)
+        let attrs = ThinVec::new();
+        Arg::from_self(attrs, eself, ident)
     }
 
     pub fn ty_param<I>(self, ident: I) -> GenericParam