---

yaml
---
r: 42362
b: refs/heads/master
c: 2bc9655
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: b8943474dc4313c432ed791cebe9b76f89b0ad84
+refs/heads/master: 2bc9655bc1a5486a2fa4cbcd7543fe094cfc4616
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
 refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650

trunk/src/librustc/driver/driver.rs

@@ -521,6 +521,9 @@ pub fn build_session_options(+binary: ~str,
     } else {
         session::unknown_crate
     };
+    let static = opt_present(matches, ~"static");
+    let gc = opt_present(matches, ~"gc");
+
     let parse_only = opt_present(matches, ~"parse-only");
     let no_trans = opt_present(matches, ~"no-trans");
 
@@ -567,6 +570,7 @@ pub fn build_session_options(+binary: ~str,
         }
     }
 
+    let jit = opt_present(matches, ~"jit");
     let output_type =
         if parse_only || no_trans {
             link::output_type_none
@@ -580,6 +584,8 @@ pub fn build_session_options(+binary: ~str,
         } else if opt_present(matches, ~"emit-llvm") {
             link::output_type_bitcode
         } else { link::output_type_exe };
+    let extra_debuginfo = opt_present(matches, ~"xg");
+    let debuginfo = opt_present(matches, ~"g") || extra_debuginfo;
     let sysroot_opt = getopts::opt_maybe_str(matches, ~"sysroot");
     let sysroot_opt = sysroot_opt.map(|m| Path(*m));
     let target_opt = getopts::opt_maybe_str(matches, ~"target");
@@ -610,12 +616,6 @@ pub fn build_session_options(+binary: ~str,
             }
         } else { No }
     };
-    let gc = debugging_opts & session::gc != 0;
-    let jit = debugging_opts & session::jit != 0;
-    let extra_debuginfo = debugging_opts & session::extra_debug_info != 0;
-    let debuginfo = debugging_opts & session::debug_info != 0 ||
-        extra_debuginfo;
-    let static = debugging_opts & session::static != 0;
     let target =
         match target_opt {
             None => host_triple(),
@@ -712,11 +712,14 @@ pub fn optgroups() -> ~[getopts::groups::OptGroup] {
                           environment", ~"SPEC"),
   optflag(~"",  ~"emit-llvm",
                         ~"Produce an LLVM bitcode file"),
+  optflag(~"g", ~"",    ~"Produce debug info (experimental)"),
+  optflag(~"",  ~"gc",  ~"Garbage collect shared data (experimental)"),
   optflag(~"h", ~"help",~"Display this message"),
   optmulti(~"L", ~"",   ~"Add a directory to the library search path",
                               ~"PATH"),
   optflag(~"",  ~"lib", ~"Compile a library crate"),
   optflag(~"",  ~"ls",  ~"List the symbols defined by a library crate"),
+  optflag(~"",  ~"jit", ~"Execute using JIT (experimental)"),
   optflag(~"", ~"no-trans",
                         ~"Run all passes except translation; no output"),
   optflag(~"O", ~"",    ~"Equivalent to --opt-level=2"),
@@ -736,9 +739,13 @@ pub fn optgroups() -> ~[getopts::groups::OptGroup] {
                           or identified (fully parenthesized,
                           AST nodes and blocks with IDs)", ~"TYPE"),
   optflag(~"S", ~"",    ~"Compile only; do not assemble or link"),
+  optflag(~"", ~"xg",   ~"Extra debugging info (experimental)"),
   optflag(~"", ~"save-temps",
                         ~"Write intermediate files (.bc, .opt.bc, .o)
                           in addition to normal output"),
+  optflag(~"", ~"static",
+                        ~"Use or produce static libraries or binaries
+                         (experimental)"),
   optopt(~"", ~"sysroot",
                         ~"Override the system root", ~"PATH"),
   optflag(~"", ~"test", ~"Build a test harness"),

trunk/src/librustc/driver/session.rs

@@ -75,11 +75,6 @@ pub const count_type_sizes: uint = 1 << 14;
 pub const meta_stats: uint = 1 << 15;
 pub const no_opt: uint = 1 << 16;
 pub const no_monomorphic_collapse: uint = 1 << 17;
-const gc: uint = 1 << 18;
-const jit: uint = 1 << 19;
-const debug_info: uint = 1 << 20;
-const extra_debug_info: uint = 1 << 21;
-const static: uint = 1 << 22;
 
 pub fn debugging_opts_map() -> ~[(~str, ~str, uint)] {
     ~[(~"verbose", ~"in general, enable more debug printouts", verbose),
@@ -107,13 +102,6 @@ pub fn debugging_opts_map() -> ~[(~str, ~str, uint)] {
      (~"no-opt", ~"do not optimize, even if -O is passed", no_opt),
      (~"no-monomorphic-collapse", ~"do not collapse template instantiations",
       no_monomorphic_collapse),
-     (~"gc", ~"Garbage collect shared data (experimental)", gc),
-     (~"jit", ~"Execute using JIT (experimental)", jit),
-     (~"extra-debug-info", ~"Extra debugging info (experimental)",
-      extra_debug_info),
-     (~"debug-info", ~"Produce debug info (experimental)", debug_info),
-     (~"static", ~"Use or produce static libraries or binaries " +
-      "(experimental)", static)
     ]
 }
 

trunk/src/librustc/middle/resolve.rs

@@ -392,17 +392,19 @@ pub struct ImportResolution {
     /// The type that this `use` directive names, if there is one.
     mut type_target: Option<Target>,
 
-    mut used: bool,
+    /// There exists one state per import statement
+    state: @mut ImportState,
 }
 
-pub fn ImportResolution(privacy: Privacy, span: span) -> ImportResolution {
+pub fn ImportResolution(privacy: Privacy, span: span,
+                        state: @mut ImportState) -> ImportResolution {
     ImportResolution {
         privacy: privacy,
         span: span,
         outstanding_references: 0,
         value_target: None,
         type_target: None,
-        used: false
+        state: state,
     }
 }
 
@@ -415,6 +417,15 @@ pub impl ImportResolution {
     }
 }
 
+pub struct ImportState {
+    used: bool,
+    warned: bool
+}
+
+pub fn ImportState() -> ImportState {
+    ImportState{ used: false, warned: false }
+}
+
 /// The link from a module up to its nearest parent node.
 pub enum ParentLink {
     NoParentLink,
@@ -1415,6 +1426,7 @@ pub impl Resolver {
 
                     // Build up the import directives.
                     let module_ = self.get_module_from_parent(parent);
+                    let state = @mut ImportState();
                     match view_path.node {
                         view_path_simple(binding, full_path, ns, _) => {
                             let ns = match ns {
@@ -1430,7 +1442,8 @@ pub impl Resolver {
                                                         module_,
                                                         module_path,
                                                         subclass,
-                                                        view_path.span);
+                                                        view_path.span,
+                                                        state);
                         }
                         view_path_list(_, ref source_idents, _) => {
                             for (*source_idents).each |source_ident| {
@@ -1442,15 +1455,17 @@ pub impl Resolver {
                                                             module_,
                                                             module_path,
                                                             subclass,
-                                                            view_path.span);
+                                                            view_path.span,
+                                                            state);
                             }
                         }
                         view_path_glob(_, _) => {
                             self.build_import_directive(privacy,
                                                         module_,
                                                         module_path,
                                                         @GlobImport,
-                                                        view_path.span);
+                                                        view_path.span,
+                                                        state);
                         }
                     }
                 }
@@ -1573,7 +1588,8 @@ pub impl Resolver {
                     // avoid creating cycles in the
                     // module graph.
 
-                    let resolution = @ImportResolution(Public, dummy_sp());
+                    let resolution = @ImportResolution(Public, dummy_sp(),
+                                                       @mut ImportState());
                     resolution.outstanding_references = 0;
 
                     match existing_module.parent_link {
@@ -1826,7 +1842,8 @@ pub impl Resolver {
                               module_: @Module,
                               module_path: @DVec<ident>,
                               subclass: @ImportDirectiveSubclass,
-                              span: span) {
+                              span: span,
+                              state: @mut ImportState) {
         let directive = @ImportDirective(privacy, module_path,
                                          subclass, span);
         module_.imports.push(directive);
@@ -1850,7 +1867,14 @@ pub impl Resolver {
                     }
                     None => {
                         debug!("(building import directive) creating new");
-                        let resolution = @ImportResolution(privacy, span);
+                        let resolution = @ImportResolution(privacy, span,
+                                                           state);
+                        let name = self.idents_to_str(module_path.get());
+                        // Don't warn about unused intrinsics because they're
+                        // automatically appended to all files
+                        if name == ~"intrinsic::rusti" {
+                            resolution.state.warned = true;
+                        }
                         resolution.outstanding_references = 1;
                         module_.import_resolutions.insert(target, resolution);
                     }
@@ -2183,7 +2207,7 @@ pub impl Resolver {
                                     return UnboundResult;
                                 }
                                 Some(target) => {
-                                    import_resolution.used = true;
+                                    import_resolution.state.used = true;
                                     return BoundResult(target.target_module,
                                                     target.bindings);
                                 }
@@ -2352,7 +2376,7 @@ pub impl Resolver {
                                     module_result = UnboundResult;
                                 }
                                 Some(target) => {
-                                    import_resolution.used = true;
+                                    import_resolution.state.used = true;
                                     module_result = BoundResult
                                         (target.target_module,
                                          target.bindings);
@@ -2419,6 +2443,7 @@ pub impl Resolver {
         // everything it can to the list of import resolutions of the module
         // node.
         debug!("(resolving glob import) resolving %? glob import", privacy);
+        let state = @mut ImportState();
 
         // We must bail out if the node has unresolved imports of any kind
         // (including globs).
@@ -2445,7 +2470,8 @@ pub impl Resolver {
                     // Simple: just copy the old import resolution.
                     let new_import_resolution =
                         @ImportResolution(privacy,
-                                          target_import_resolution.span);
+                                          target_import_resolution.span,
+                                          state);
                     new_import_resolution.value_target =
                         copy target_import_resolution.value_target;
                     new_import_resolution.type_target =
@@ -2486,7 +2512,8 @@ pub impl Resolver {
             match module_.import_resolutions.find(&ident) {
                 None => {
                     // Create a new import resolution from this child.
-                    dest_import_resolution = @ImportResolution(privacy, span);
+                    dest_import_resolution = @ImportResolution(privacy, span,
+                                                               state);
                     module_.import_resolutions.insert
                         (ident, dest_import_resolution);
                 }
@@ -2713,7 +2740,7 @@ pub impl Resolver {
                                namespace);
                     }
                     Some(target) => {
-                        import_resolution.used = true;
+                        import_resolution.state.used = true;
                         return Success(copy target);
                     }
                 }
@@ -2962,7 +2989,7 @@ pub impl Resolver {
                     Some(target) => {
                         debug!("(resolving name in module) resolved to \
                                 import");
-                        import_resolution.used = true;
+                        import_resolution.state.used = true;
                         return Success(copy target);
                     }
                 }
@@ -4560,7 +4587,7 @@ pub impl Resolver {
                                     namespace)) {
                             (Some(def), Some(Public)) => {
                                 // Found it.
-                                import_resolution.used = true;
+                                import_resolution.state.used = true;
                                 return ImportNameDefinition(def);
                             }
                             (Some(_), _) | (None, _) => {
@@ -5034,9 +5061,13 @@ pub impl Resolver {
                             Some(def) => {
                                 match def {
                                     def_ty(trait_def_id) => {
-                                        self.
+                                        let added = self.
                                         add_trait_info_if_containing_method(
                                         found_traits, trait_def_id, name);
+                                        if added {
+                                            import_resolution.state.used =
+                                                true;
+                                        }
                                     }
                                     _ => {
                                         // Continue.
@@ -5069,7 +5100,7 @@ pub impl Resolver {
 
     fn add_trait_info_if_containing_method(found_traits: @DVec<def_id>,
                                            trait_def_id: def_id,
-                                           name: ident) {
+                                           name: ident) -> bool {
 
         debug!("(adding trait info if containing method) trying trait %d:%d \
                 for method '%s'",
@@ -5085,9 +5116,10 @@ pub impl Resolver {
                        trait_def_id.node,
                        self.session.str_of(name));
                 (*found_traits).push(trait_def_id);
+                true
             }
             Some(_) | None => {
-                // Continue.
+                false
             }
         }
     }
@@ -5204,7 +5236,13 @@ pub impl Resolver {
 
     fn check_for_unused_imports_in_module(module_: @Module) {
         for module_.import_resolutions.each_value_ref |&import_resolution| {
-            if !import_resolution.used {
+            // Ignore dummy spans for things like automatically injected
+            // imports for the prelude, and also don't warn about the same
+            // import statement being unused more than once.
+            if !import_resolution.state.used &&
+                    !import_resolution.state.warned &&
+                    import_resolution.span != dummy_sp() {
+                import_resolution.state.warned = true;
                 match self.unused_import_lint_level {
                     warn => {
                         self.session.span_warn(import_resolution.span,