Merge pull request rust-lang#72 from AwesomeCompiler/feature/edition-2018

(master) Update to 2018 edition

Author: TheDan64

Cargo.toml

@@ -5,10 +5,10 @@ authors = ["Daniel Kolsoi <[email protected]>"]
 description = "Inkwell aims to help you pen your own programming languages by safely wrapping llvm-sys."
 repository = "https://github.com/TheDan64/inkwell"
 readme = "README.md"
-changelog = "CHANGELOG.md"
 keywords = ["llvm", "safe", "wrapper"]
 license = "Apache-2.0"
 categories = ["development-tools::ffi"]
+edition = "2018"
 
 [features]
 default = []

README.md

@@ -5,17 +5,17 @@
 [![codecov](https://codecov.io/gh/TheDan64/inkwell/branch/master/graph/badge.svg)](https://codecov.io/gh/TheDan64/inkwell)
 [![lines of code](https://tokei.rs/b1/github/TheDan64/inkwell)](https://github.com/Aaronepower/tokei)
 [![Join the chat at https://gitter.im/inkwell-rs/Lobby](https://badges.gitter.im/inkwell-rs/Lobby.svg)](https://gitter.im/inkwell-rs/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-![Minimum rustc 1.30](https://img.shields.io/badge/rustc-1.30+-brightgreen.svg)
+![Minimum rustc 1.31](https://img.shields.io/badge/rustc-1.31+-brightgreen.svg)
 
 **I**t's a **N**ew **K**ind of **W**rapper for **E**xposing **LL**VM (*S*afely)
 
 Inkwell aims to help you pen your own programming languages by safely wrapping llvm-sys. It provides a more strongly typed interface than the underlying LLVM API so that certain types of errors can be caught at compile time instead of at LLVM's runtime. This means we are trying to replicate LLVM IR's strong typing as closely as possible. The ultimate goal is to make LLVM safer from the rust end and a bit easier to learn (via documentation) and use.
 
 ## Requirements
 
-* Rust 1.30+
+* Rust 1.31+
 * Rust Stable, Beta, or Nightly
-* LLVM 3.6, 3.7, 3.8, 3.9, 4.0, 5.0, 6.0, or 7
+* LLVM 3.6, 3.7, 3.8, 3.9, 4.0, 5.0, 6.0, or 7.0
 
 ## Usage
 
@@ -48,8 +48,6 @@ Documentation is automatically [deployed here](https://thedan64.github.io/inkwel
 ### Tari's [llvm-sys example](https://bitbucket.org/tari/llvm-sys.rs/src/ea4ac92a171da2c1851806b91e531ed3a0b41091/examples/jit-function.rs) written in safe code<sup>1</sup> with Inkwell:
 
 ```rust
-extern crate inkwell;
-
 use inkwell::OptimizationLevel;
 use inkwell::builder::Builder;
 use inkwell::context::Context;

examples/kaleidoscope/main.rs

@@ -30,7 +30,7 @@ use self::inkwell::types::BasicTypeEnum;
 use self::inkwell::values::{BasicValueEnum, FloatValue, FunctionValue, PointerValue};
 use self::inkwell::{OptimizationLevel, FloatPredicate};
 
-use Token::*;
+use crate::Token::*;
 
 const ANONYMOUS_FUNCTION_NAME: &str = "anonymous";
 

internal_macros/Cargo.toml

@@ -2,6 +2,7 @@
 name = "inkwell_internal_macros"
 version = "0.1.0"
 authors = ["Daniel Kolsoi <[email protected]>"]
+edition = "2018"
 
 [dependencies]
 quote = "0.6"

src/basic_block.rs

@@ -5,8 +5,8 @@ use llvm_sys::core::{LLVMGetBasicBlockParent, LLVMGetBasicBlockTerminator, LLVMG
 use llvm_sys::core::LLVMGetBasicBlockName;
 use llvm_sys::prelude::{LLVMValueRef, LLVMBasicBlockRef};
 
-use context::{Context, ContextRef};
-use values::{FunctionValue, InstructionValue};
+use crate::context::{Context, ContextRef};
+use crate::values::{FunctionValue, InstructionValue};
 
 use std::fmt;
 use std::ffi::{CStr, CString};

src/builder.rs

@@ -3,10 +3,10 @@ use llvm_sys::core::{LLVMBuildAdd, LLVMBuildAlloca, LLVMBuildAnd, LLVMBuildArray
 use llvm_sys::prelude::{LLVMBuilderRef, LLVMValueRef};
 use llvm_sys::{LLVMTypeKind};
 
-use {AtomicOrdering, IntPredicate, FloatPredicate};
-use basic_block::BasicBlock;
-use values::{AggregateValue, AggregateValueEnum, AsValueRef, BasicValue, BasicValueEnum, PhiValue, FunctionValue, IntValue, PointerValue, VectorValue, InstructionValue, GlobalValue, IntMathValue, FloatMathValue, PointerMathValue, InstructionOpcode, CallSiteValue};
-use types::{AsTypeRef, BasicType, IntMathType, FloatMathType, PointerType, PointerMathType};
+use crate::{AtomicOrdering, IntPredicate, FloatPredicate};
+use crate::basic_block::BasicBlock;
+use crate::values::{AggregateValue, AggregateValueEnum, AsValueRef, BasicValue, BasicValueEnum, PhiValue, FunctionValue, IntValue, PointerValue, VectorValue, InstructionValue, GlobalValue, IntMathValue, FloatMathValue, PointerMathValue, InstructionOpcode, CallSiteValue};
+use crate::types::{AsTypeRef, BasicType, IntMathType, FloatMathType, PointerType, PointerMathType};
 
 use std::ffi::CString;
 
@@ -667,6 +667,11 @@ impl Builder {
     /// if the leftmost bit was one.
     ///
     /// ```rust,no_run
+    /// //fix doc error about overflowing_literals
+    /// //rendered rfc: https://github.com/rust-lang/rfcs/blob/master/text/2438-deny-integer-literal-overflow-lint.md
+    /// //tracking issue: https://github.com/rust-lang/rust/issues/54502
+    /// #![allow(overflowing_literals)]
+    ///
     /// // Logical Right Shift
     /// assert_eq!(0b1100_0000 >> 2, 0b0011_0000);
     /// assert_eq!(0b0000_0010 >> 1, 0b0000_0001);

src/context.rs

@@ -8,14 +8,14 @@ use llvm_sys::ir_reader::LLVMParseIRInContext;
 use libc::c_void;
 
 #[llvm_versions(4.0 => latest)]
-use attributes::Attribute;
-use basic_block::BasicBlock;
-use builder::Builder;
-use memory_buffer::MemoryBuffer;
-use module::Module;
-use support::LLVMString;
-use types::{BasicTypeEnum, FloatType, IntType, StructType, VoidType, AsTypeRef};
-use values::{AsValueRef, FunctionValue, StructValue, MetadataValue, BasicValueEnum, VectorValue};
+use crate::attributes::Attribute;
+use crate::basic_block::BasicBlock;
+use crate::builder::Builder;
+use crate::memory_buffer::MemoryBuffer;
+use crate::module::Module;
+use crate::support::LLVMString;
+use crate::types::{BasicTypeEnum, FloatType, IntType, StructType, VoidType, AsTypeRef};
+use crate::values::{AsValueRef, FunctionValue, StructValue, MetadataValue, BasicValueEnum, VectorValue};
 
 use std::ffi::CString;
 use std::mem::forget;

src/data_layout.rs

@@ -1,7 +1,7 @@
 use std::ffi::CStr;
 use std::fmt;
 
-use support::{LLVMString, LLVMStringOrRaw};
+use crate::support::{LLVMString, LLVMStringOrRaw};
 
 #[derive(Eq)]
 pub struct DataLayout {

src/execution_engine.rs

@@ -1,11 +1,11 @@
 use libc::c_int;
 use llvm_sys::execution_engine::{LLVMGetExecutionEngineTargetData, LLVMExecutionEngineRef, LLVMRunFunction, LLVMRunFunctionAsMain, LLVMDisposeExecutionEngine, LLVMGetFunctionAddress, LLVMAddModule, LLVMFindFunction, LLVMLinkInMCJIT, LLVMLinkInInterpreter, LLVMRemoveModule, LLVMGenericValueRef, LLVMFreeMachineCodeForFunction, LLVMAddGlobalMapping, LLVMRunStaticConstructors, LLVMRunStaticDestructors};
 
-use context::Context;
-use module::Module;
-use support::LLVMString;
-use targets::TargetData;
-use values::{AnyValue, AsValueRef, FunctionValue, GenericValue};
+use crate::context::Context;
+use crate::module::Module;
+use crate::support::LLVMString;
+use crate::targets::TargetData;
+use crate::values::{AnyValue, AsValueRef, FunctionValue, GenericValue};
 
 use std::error::Error;
 use std::rc::Rc;

src/memory_buffer.rs

@@ -2,8 +2,8 @@ use llvm_sys::core::{LLVMCreateMemoryBufferWithContentsOfFile, LLVMCreateMemoryB
 use llvm_sys::prelude::LLVMMemoryBufferRef;
 use llvm_sys::object::LLVMCreateObjectFile;
 
-use object_file::ObjectFile;
-use support::LLVMString;
+use crate::object_file::ObjectFile;
+use crate::support::LLVMString;
 
 use std::ffi::CString;
 use std::mem::{forget, zeroed};

src/module.rs

@@ -26,19 +26,19 @@ use std::ptr;
 use std::rc::Rc;
 use std::slice::from_raw_parts;
 
-use {AddressSpace, OptimizationLevel};
+use crate::{AddressSpace, OptimizationLevel};
 #[llvm_versions(7.0 => latest)]
-use comdat::Comdat;
-use context::{Context, ContextRef};
-use data_layout::DataLayout;
-use execution_engine::ExecutionEngine;
-use memory_buffer::MemoryBuffer;
-use support::LLVMString;
-use targets::{Target, InitializationConfig};
-use types::{AsTypeRef, BasicType, FunctionType, BasicTypeEnum};
-use values::{AsValueRef, FunctionValue, GlobalValue, MetadataValue};
+use crate::comdat::Comdat;
+use crate::context::{Context, ContextRef};
+use crate::data_layout::DataLayout;
+use crate::execution_engine::ExecutionEngine;
+use crate::memory_buffer::MemoryBuffer;
+use crate::support::LLVMString;
+use crate::targets::{Target, InitializationConfig};
+use crate::types::{AsTypeRef, BasicType, FunctionType, BasicTypeEnum};
+use crate::values::{AsValueRef, FunctionValue, GlobalValue, MetadataValue};
 #[llvm_versions(7.0 => latest)]
-use values::BasicValue;
+use crate::values::BasicValue;
 
 enum_rename!{
     /// This enum defines how to link a global variable or function in a module. The variant documenation is
@@ -1292,7 +1292,7 @@ impl Module {
         }
         #[cfg(not(any(feature = "llvm3-6", feature = "llvm3-7")))]
         {
-            use support::error_handling::get_error_str_diagnostic_handler;
+            use crate::support::error_handling::get_error_str_diagnostic_handler;
             use llvm_sys::linker::LLVMLinkModules2;
             use libc::c_void;
 

src/passes.rs

@@ -8,11 +8,11 @@ use llvm_sys::transforms::scalar::{LLVMAddAggressiveDCEPass, LLVMAddMemCpyOptPas
 use llvm_sys::transforms::scalar::LLVMAddBitTrackingDCEPass;
 use llvm_sys::transforms::vectorize::{LLVMAddLoopVectorizePass, LLVMAddSLPVectorizePass};
 
-use OptimizationLevel;
-use module::Module;
+use crate::OptimizationLevel;
+use crate::module::Module;
 #[llvm_versions(3.6 => 3.8)]
-use targets::TargetData;
-use values::{AsValueRef, FunctionValue};
+use crate::targets::TargetData;
+use crate::values::{AsValueRef, FunctionValue};
 
 // REVIEW: Opt Level might be identical to targets::Option<CodeGenOptLevel>
 #[derive(Debug)]

src/targets.rs

@@ -3,15 +3,15 @@ use either::Either;
 use llvm_sys::target::{LLVMTargetDataRef, LLVMCopyStringRepOfTargetData, LLVMSizeOfTypeInBits, LLVMCreateTargetData, LLVMByteOrder, LLVMPointerSize, LLVMByteOrdering, LLVMStoreSizeOfType, LLVMABISizeOfType, LLVMABIAlignmentOfType, LLVMCallFrameAlignmentOfType, LLVMPreferredAlignmentOfType, LLVMPreferredAlignmentOfGlobal, LLVMElementAtOffset, LLVMOffsetOfElement, LLVMDisposeTargetData, LLVMPointerSizeForAS, LLVMIntPtrType, LLVMIntPtrTypeForAS, LLVMIntPtrTypeInContext, LLVMIntPtrTypeForASInContext};
 use llvm_sys::target_machine::{LLVMGetFirstTarget, LLVMTargetRef, LLVMGetNextTarget, LLVMGetTargetFromName, LLVMGetTargetFromTriple, LLVMGetTargetName, LLVMGetTargetDescription, LLVMTargetHasJIT, LLVMTargetHasTargetMachine, LLVMTargetHasAsmBackend, LLVMTargetMachineRef, LLVMDisposeTargetMachine, LLVMGetTargetMachineTarget, LLVMGetTargetMachineTriple, LLVMSetTargetMachineAsmVerbosity, LLVMCreateTargetMachine, LLVMGetTargetMachineCPU, LLVMGetTargetMachineFeatureString, LLVMGetDefaultTargetTriple, LLVMAddAnalysisPasses, LLVMCodeGenOptLevel, LLVMCodeModel, LLVMRelocMode, LLVMCodeGenFileType, LLVMTargetMachineEmitToMemoryBuffer, LLVMTargetMachineEmitToFile};
 
-use {AddressSpace, OptimizationLevel};
-use context::Context;
-use data_layout::DataLayout;
-use memory_buffer::MemoryBuffer;
-use module::Module;
-use passes::PassManager;
-use support::LLVMString;
-use types::{AnyType, AsTypeRef, IntType, StructType};
-use values::{AsValueRef, GlobalValue};
+use crate::{AddressSpace, OptimizationLevel};
+use crate::context::Context;
+use crate::data_layout::DataLayout;
+use crate::memory_buffer::MemoryBuffer;
+use crate::module::Module;
+use crate::passes::PassManager;
+use crate::support::LLVMString;
+use crate::types::{AnyType, AsTypeRef, IntType, StructType};
+use crate::values::{AsValueRef, GlobalValue};
 
 use std::default::Default;
 use std::ffi::{CStr, CString};

src/types/array_type.rs

@@ -1,12 +1,12 @@
 use llvm_sys::core::{LLVMConstArray, LLVMGetArrayLength};
 use llvm_sys::prelude::{LLVMTypeRef, LLVMValueRef};
 
-use AddressSpace;
-use context::ContextRef;
-use support::LLVMString;
-use types::traits::AsTypeRef;
-use types::{Type, BasicTypeEnum, PointerType, FunctionType};
-use values::{AsValueRef, ArrayValue, IntValue};
+use crate::AddressSpace;
+use crate::context::ContextRef;
+use crate::support::LLVMString;
+use crate::types::traits::AsTypeRef;
+use crate::types::{Type, BasicTypeEnum, PointerType, FunctionType};
+use crate::values::{AsValueRef, ArrayValue, IntValue};
 
 /// An `ArrayType` is the type of contiguous constants or variables.
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]

src/types/enums.rs

@@ -2,8 +2,8 @@ use llvm_sys::core::LLVMGetTypeKind;
 use llvm_sys::LLVMTypeKind;
 use llvm_sys::prelude::LLVMTypeRef;
 
-use types::{IntType, VoidType, FunctionType, PointerType, VectorType, ArrayType, StructType, FloatType};
-use types::traits::AsTypeRef;
+use crate::types::{IntType, VoidType, FunctionType, PointerType, VectorType, ArrayType, StructType, FloatType};
+use crate::types::traits::AsTypeRef;
 
 macro_rules! enum_type_set {
     ($(#[$enum_attrs:meta])* $enum_name:ident: { $($(#[$variant_attrs:meta])* $args:ident,)+ }) => (

src/types/float_type.rs

@@ -2,12 +2,12 @@ use llvm_sys::core::{LLVMConstReal, LLVMHalfType, LLVMFloatType, LLVMDoubleType,
 use llvm_sys::execution_engine::LLVMCreateGenericValueOfFloat;
 use llvm_sys::prelude::{LLVMTypeRef, LLVMValueRef};
 
-use AddressSpace;
-use context::ContextRef;
-use support::LLVMString;
-use types::traits::AsTypeRef;
-use types::{Type, PointerType, FunctionType, BasicTypeEnum, ArrayType, VectorType};
-use values::{AsValueRef, ArrayValue, FloatValue, GenericValue, IntValue};
+use crate::AddressSpace;
+use crate::context::ContextRef;
+use crate::support::LLVMString;
+use crate::types::traits::AsTypeRef;
+use crate::types::{Type, PointerType, FunctionType, BasicTypeEnum, ArrayType, VectorType};
+use crate::values::{AsValueRef, ArrayValue, FloatValue, GenericValue, IntValue};
 
 /// A `FloatType` is the type of a floating point constant or variable.
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]

src/types/fn_type.rs

@@ -4,11 +4,11 @@ use llvm_sys::prelude::LLVMTypeRef;
 use std::fmt;
 use std::mem::forget;
 
-use AddressSpace;
-use context::ContextRef;
-use support::LLVMString;
-use types::traits::AsTypeRef;
-use types::{PointerType, Type, BasicTypeEnum};
+use crate::AddressSpace;
+use crate::context::ContextRef;
+use crate::support::LLVMString;
+use crate::types::traits::AsTypeRef;
+use crate::types::{PointerType, Type, BasicTypeEnum};
 
 // REVIEW: Add a get_return_type() -> Option<BasicTypeEnum>?
 /// A `FunctionType` is the type of a function variable.

src/types/int_type.rs

@@ -2,12 +2,12 @@ use llvm_sys::core::{LLVMInt1Type, LLVMInt8Type, LLVMInt16Type, LLVMInt32Type, L
 use llvm_sys::execution_engine::LLVMCreateGenericValueOfInt;
 use llvm_sys::prelude::{LLVMTypeRef, LLVMValueRef};
 
-use AddressSpace;
-use context::ContextRef;
-use support::LLVMString;
-use types::traits::AsTypeRef;
-use types::{Type, ArrayType, BasicTypeEnum, VectorType, PointerType, FunctionType};
-use values::{AsValueRef, ArrayValue, GenericValue, IntValue};
+use crate::AddressSpace;
+use crate::context::ContextRef;
+use crate::support::LLVMString;
+use crate::types::traits::AsTypeRef;
+use crate::types::{Type, ArrayType, BasicTypeEnum, VectorType, PointerType, FunctionType};
+use crate::values::{AsValueRef, ArrayValue, GenericValue, IntValue};
 
 /// An `IntType` is the type of an integer constant or variable.
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]

src/types/mod.rs

@@ -20,17 +20,17 @@ mod vec_type;
 #[deny(missing_docs)]
 mod void_type;
 
-pub use types::array_type::ArrayType;
-pub use types::enums::{AnyTypeEnum, BasicTypeEnum};
-pub use types::float_type::FloatType;
-pub use types::fn_type::FunctionType;
-pub use types::int_type::IntType;
-pub use types::ptr_type::PointerType;
-pub use types::struct_type::StructType;
-pub use types::traits::{AnyType, BasicType, IntMathType, FloatMathType, PointerMathType};
-pub use types::vec_type::VectorType;
-pub use types::void_type::VoidType;
-pub(crate) use types::traits::AsTypeRef;
+pub use crate::types::array_type::ArrayType;
+pub use crate::types::enums::{AnyTypeEnum, BasicTypeEnum};
+pub use crate::types::float_type::FloatType;
+pub use crate::types::fn_type::FunctionType;
+pub use crate::types::int_type::IntType;
+pub use crate::types::ptr_type::PointerType;
+pub use crate::types::struct_type::StructType;
+pub use crate::types::traits::{AnyType, BasicType, IntMathType, FloatMathType, PointerMathType};
+pub use crate::types::vec_type::VectorType;
+pub use crate::types::void_type::VoidType;
+pub(crate) use crate::types::traits::AsTypeRef;
 
 #[llvm_versions(3.7 => 4.0)]
 use llvm_sys::core::LLVMDumpType;
@@ -40,10 +40,10 @@ use llvm_sys::prelude::{LLVMTypeRef, LLVMValueRef};
 use std::fmt;
 use std::rc::Rc;
 
-use AddressSpace;
-use context::{Context, ContextRef};
-use support::LLVMString;
-use values::IntValue;
+use crate::AddressSpace;
+use crate::context::{Context, ContextRef};
+use crate::support::LLVMString;
+use crate::values::IntValue;
 
 // Worth noting that types seem to be singletons. At the very least, primitives are.
 // Though this is likely only true per thread since LLVM claims to not be very thread-safe.

src/types/ptr_type.rs

@@ -1,12 +1,12 @@
 use llvm_sys::core::{LLVMGetPointerAddressSpace, LLVMConstArray};
 use llvm_sys::prelude::{LLVMTypeRef, LLVMValueRef};
 
-use AddressSpace;
-use context::ContextRef;
-use support::LLVMString;
-use types::traits::AsTypeRef;
-use types::{AnyTypeEnum, Type, BasicTypeEnum, ArrayType, FunctionType, VectorType};
-use values::{AsValueRef, ArrayValue, PointerValue, IntValue};
+use crate::AddressSpace;
+use crate::context::ContextRef;
+use crate::support::LLVMString;
+use crate::types::traits::AsTypeRef;
+use crate::types::{AnyTypeEnum, Type, BasicTypeEnum, ArrayType, FunctionType, VectorType};
+use crate::values::{AsValueRef, ArrayValue, PointerValue, IntValue};
 
 /// A `PointerType` is the type of a pointer constant or variable.
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]