---

yaml
---
r: 42363
b: refs/heads/master
c: fae8fc9
h: refs/heads/master
i:
  42361: 568f8b0
  42359: 41d59a8
v: v3

Author: veddan

[refs]

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

trunk/src/librustc/driver/driver.rs

@@ -521,9 +521,6 @@ 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");
 
@@ -570,7 +567,6 @@ 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
@@ -584,8 +580,6 @@ 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");
@@ -616,6 +610,12 @@ 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,14 +712,11 @@ 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"),
@@ -739,13 +736,9 @@ 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,6 +75,11 @@ 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;
+pub const gc: uint = 1 << 18;
+pub const jit: uint = 1 << 19;
+pub const debug_info: uint = 1 << 20;
+pub const extra_debug_info: uint = 1 << 21;
+pub const static: uint = 1 << 22;
 
 pub fn debugging_opts_map() -> ~[(~str, ~str, uint)] {
     ~[(~"verbose", ~"in general, enable more debug printouts", verbose),
@@ -102,6 +107,13 @@ 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,19 +392,17 @@ pub struct ImportResolution {
     /// The type that this `use` directive names, if there is one.
     mut type_target: Option<Target>,
 
-    /// There exists one state per import statement
-    state: @mut ImportState,
+    mut used: bool,
 }
 
-pub fn ImportResolution(privacy: Privacy, span: span,
-                        state: @mut ImportState) -> ImportResolution {
+pub fn ImportResolution(privacy: Privacy, span: span) -> ImportResolution {
     ImportResolution {
         privacy: privacy,
         span: span,
         outstanding_references: 0,
         value_target: None,
         type_target: None,
-        state: state,
+        used: false
     }
 }
 
@@ -417,15 +415,6 @@ 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,
@@ -1426,7 +1415,6 @@ 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 {
@@ -1442,8 +1430,7 @@ pub impl Resolver {
                                                         module_,
                                                         module_path,
                                                         subclass,
-                                                        view_path.span,
-                                                        state);
+                                                        view_path.span);
                         }
                         view_path_list(_, ref source_idents, _) => {
                             for (*source_idents).each |source_ident| {
@@ -1455,17 +1442,15 @@ pub impl Resolver {
                                                             module_,
                                                             module_path,
                                                             subclass,
-                                                            view_path.span,
-                                                            state);
+                                                            view_path.span);
                             }
                         }
                         view_path_glob(_, _) => {
                             self.build_import_directive(privacy,
                                                         module_,
                                                         module_path,
                                                         @GlobImport,
-                                                        view_path.span,
-                                                        state);
+                                                        view_path.span);
                         }
                     }
                 }
@@ -1588,8 +1573,7 @@ pub impl Resolver {
                     // avoid creating cycles in the
                     // module graph.
 
-                    let resolution = @ImportResolution(Public, dummy_sp(),
-                                                       @mut ImportState());
+                    let resolution = @ImportResolution(Public, dummy_sp());
                     resolution.outstanding_references = 0;
 
                     match existing_module.parent_link {
@@ -1842,8 +1826,7 @@ pub impl Resolver {
                               module_: @Module,
                               module_path: @DVec<ident>,
                               subclass: @ImportDirectiveSubclass,
-                              span: span,
-                              state: @mut ImportState) {
+                              span: span) {
         let directive = @ImportDirective(privacy, module_path,
                                          subclass, span);
         module_.imports.push(directive);
@@ -1867,14 +1850,7 @@ pub impl Resolver {
                     }
                     None => {
                         debug!("(building import directive) creating new");
-                        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;
-                        }
+                        let resolution = @ImportResolution(privacy, span);
                         resolution.outstanding_references = 1;
                         module_.import_resolutions.insert(target, resolution);
                     }
@@ -2207,7 +2183,7 @@ pub impl Resolver {
                                     return UnboundResult;
                                 }
                                 Some(target) => {
-                                    import_resolution.state.used = true;
+                                    import_resolution.used = true;
                                     return BoundResult(target.target_module,
                                                     target.bindings);
                                 }
@@ -2376,7 +2352,7 @@ pub impl Resolver {
                                     module_result = UnboundResult;
                                 }
                                 Some(target) => {
-                                    import_resolution.state.used = true;
+                                    import_resolution.used = true;
                                     module_result = BoundResult
                                         (target.target_module,
                                          target.bindings);
@@ -2443,7 +2419,6 @@ 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).
@@ -2470,8 +2445,7 @@ pub impl Resolver {
                     // Simple: just copy the old import resolution.
                     let new_import_resolution =
                         @ImportResolution(privacy,
-                                          target_import_resolution.span,
-                                          state);
+                                          target_import_resolution.span);
                     new_import_resolution.value_target =
                         copy target_import_resolution.value_target;
                     new_import_resolution.type_target =
@@ -2512,8 +2486,7 @@ pub impl Resolver {
             match module_.import_resolutions.find(&ident) {
                 None => {
                     // Create a new import resolution from this child.
-                    dest_import_resolution = @ImportResolution(privacy, span,
-                                                               state);
+                    dest_import_resolution = @ImportResolution(privacy, span);
                     module_.import_resolutions.insert
                         (ident, dest_import_resolution);
                 }
@@ -2740,7 +2713,7 @@ pub impl Resolver {
                                namespace);
                     }
                     Some(target) => {
-                        import_resolution.state.used = true;
+                        import_resolution.used = true;
                         return Success(copy target);
                     }
                 }
@@ -2989,7 +2962,7 @@ pub impl Resolver {
                     Some(target) => {
                         debug!("(resolving name in module) resolved to \
                                 import");
-                        import_resolution.state.used = true;
+                        import_resolution.used = true;
                         return Success(copy target);
                     }
                 }
@@ -4587,7 +4560,7 @@ pub impl Resolver {
                                     namespace)) {
                             (Some(def), Some(Public)) => {
                                 // Found it.
-                                import_resolution.state.used = true;
+                                import_resolution.used = true;
                                 return ImportNameDefinition(def);
                             }
                             (Some(_), _) | (None, _) => {
@@ -5061,13 +5034,9 @@ pub impl Resolver {
                             Some(def) => {
                                 match def {
                                     def_ty(trait_def_id) => {
-                                        let added = self.
+                                        self.
                                         add_trait_info_if_containing_method(
                                         found_traits, trait_def_id, name);
-                                        if added {
-                                            import_resolution.state.used =
-                                                true;
-                                        }
                                     }
                                     _ => {
                                         // Continue.
@@ -5100,7 +5069,7 @@ pub impl Resolver {
 
     fn add_trait_info_if_containing_method(found_traits: @DVec<def_id>,
                                            trait_def_id: def_id,
-                                           name: ident) -> bool {
+                                           name: ident) {
 
         debug!("(adding trait info if containing method) trying trait %d:%d \
                 for method '%s'",
@@ -5116,10 +5085,9 @@ pub impl Resolver {
                        trait_def_id.node,
                        self.session.str_of(name));
                 (*found_traits).push(trait_def_id);
-                true
             }
             Some(_) | None => {
-                false
+                // Continue.
             }
         }
     }
@@ -5236,13 +5204,7 @@ pub impl Resolver {
 
     fn check_for_unused_imports_in_module(module_: @Module) {
         for module_.import_resolutions.each_value_ref |&import_resolution| {
-            // 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;
+            if !import_resolution.used {
                 match self.unused_import_lint_level {
                     warn => {
                         self.session.span_warn(import_resolution.span,