rustdoc: Use unboxed closure sugar

This unfortunately leaves sugaring Fn/FnMut/FnOnce on cross-crate
re-exports for future work.

cc #19909

Author: tomjakubowski

src/librustdoc/clean/mod.rs

@@ -526,8 +526,10 @@ fn external_path(cx: &DocContext, name: &str, substs: &subst::Substs) -> Path {
         global: false,
         segments: vec![PathSegment {
             name: name.to_string(),
-            lifetimes: lifetimes,
-            types: types,
+            params: PathParameters::AngleBracketed {
+                lifetimes: lifetimes,
+                types: types,
+            }
         }],
     }
 }
@@ -1744,31 +1746,48 @@ impl Clean<Path> for ast::Path {
 }
 
 #[deriving(Clone, RustcEncodable, RustcDecodable, PartialEq)]
-pub struct PathSegment {
-    pub name: String,
-    pub lifetimes: Vec<Lifetime>,
-    pub types: Vec<Type>,
+pub enum PathParameters {
+    AngleBracketed {
+        lifetimes: Vec<Lifetime>,
+        types: Vec<Type>,
+    },
+    Parenthesized {
+        inputs: Vec<Type>,
+        output: Option<Type>
+    }
 }
 
-impl Clean<PathSegment> for ast::PathSegment {
-    fn clean(&self, cx: &DocContext) -> PathSegment {
-        let (lifetimes, types) = match self.parameters {
+impl Clean<PathParameters> for ast::PathParameters {
+    fn clean(&self, cx: &DocContext) -> PathParameters {
+        match *self {
             ast::AngleBracketedParameters(ref data) => {
-                (data.lifetimes.clean(cx), data.types.clean(cx))
+                PathParameters::AngleBracketed {
+                    lifetimes: data.lifetimes.clean(cx),
+                    types: data.types.clean(cx)
+                }
             }
 
             ast::ParenthesizedParameters(ref data) => {
-                // FIXME -- rustdoc should be taught about Foo() notation
-                let inputs = Tuple(data.inputs.clean(cx));
-                let output = data.output.as_ref().map(|t| t.clean(cx)).unwrap_or(Tuple(Vec::new()));
-                (Vec::new(), vec![inputs, output])
+                PathParameters::Parenthesized {
+                    inputs: data.inputs.clean(cx),
+                    output: data.output.clean(cx)
+                }
             }
-        };
+        }
+    }
+}
 
+#[deriving(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+pub struct PathSegment {
+    pub name: String,
+    pub params: PathParameters
+}
+
+impl Clean<PathSegment> for ast::PathSegment {
+    fn clean(&self, cx: &DocContext) -> PathSegment {
         PathSegment {
             name: self.identifier.clean(cx),
-            lifetimes: lifetimes,
-            types: types,
+            params: self.parameters.clean(cx)
         }
     }
 }
@@ -2399,8 +2418,10 @@ fn lang_struct(cx: &DocContext, did: Option<ast::DefId>,
             global: false,
             segments: vec![PathSegment {
                 name: name.to_string(),
-                lifetimes: vec![],
-                types: vec![t.clean(cx)],
+                params: PathParameters::AngleBracketed {
+                    lifetimes: vec![],
+                    types: vec![t.clean(cx)],
+                }
             }],
         },
     }

src/librustdoc/html/format.rs

@@ -171,37 +171,69 @@ impl fmt::Show for clean::TyParamBound {
     }
 }
 
-impl fmt::Show for clean::Path {
+impl fmt::Show for clean::PathParameters {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if self.global {
-            try!(f.write("::".as_bytes()))
-        }
-
-        for (i, seg) in self.segments.iter().enumerate() {
-            if i > 0 {
-                try!(f.write("::".as_bytes()))
-            }
-            try!(f.write(seg.name.as_bytes()));
-
-            if seg.lifetimes.len() > 0 || seg.types.len() > 0 {
-                try!(f.write("<".as_bytes()));
-                let mut comma = false;
-                for lifetime in seg.lifetimes.iter() {
-                    if comma {
-                        try!(f.write(", ".as_bytes()));
+        match *self {
+            clean::PathParameters::AngleBracketed { ref lifetimes, ref types } => {
+                if lifetimes.len() > 0 || types.len() > 0 {
+                    try!(f.write("<".as_bytes()));
+                    let mut comma = false;
+                    for lifetime in lifetimes.iter() {
+                        if comma {
+                            try!(f.write(", ".as_bytes()));
+                        }
+                        comma = true;
+                        try!(write!(f, "{}", *lifetime));
                     }
-                    comma = true;
-                    try!(write!(f, "{}", *lifetime));
+                    for ty in types.iter() {
+                        if comma {
+                            try!(f.write(", ".as_bytes()));
+                        }
+                        comma = true;
+                        try!(write!(f, "{}", *ty));
+                    }
+                    try!(f.write(">".as_bytes()));
                 }
-                for ty in seg.types.iter() {
+            }
+            clean::PathParameters::Parenthesized { ref inputs, ref output } => {
+                try!(f.write("(".as_bytes()));
+                let mut comma = false;
+                for ty in inputs.iter() {
                     if comma {
                         try!(f.write(", ".as_bytes()));
                     }
                     comma = true;
                     try!(write!(f, "{}", *ty));
                 }
-                try!(f.write(">".as_bytes()));
+                try!(f.write(")".as_bytes()));
+                if let Some(ref ty) = *output {
+                    try!(f.write(" -> ".as_bytes()));
+                    try!(write!(f, "{}", ty));
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+impl fmt::Show for clean::PathSegment {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        try!(f.write(self.name.as_bytes()));
+        write!(f, "{}", self.params)
+    }
+}
+
+impl fmt::Show for clean::Path {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if self.global {
+            try!(f.write("::".as_bytes()))
+        }
+
+        for (i, seg) in self.segments.iter().enumerate() {
+            if i > 0 {
+                try!(f.write("::".as_bytes()))
             }
+            try!(write!(f, "{}", seg));
         }
         Ok(())
     }
@@ -243,23 +275,8 @@ fn path<F, G>(w: &mut fmt::Formatter,
     G: FnOnce(&render::Cache) -> Option<(Vec<String>, ItemType)>,
 {
     // The generics will get written to both the title and link
-    let mut generics = String::new();
     let last = path.segments.last().unwrap();
-    if last.lifetimes.len() > 0 || last.types.len() > 0 {
-        let mut counter = 0u;
-        generics.push_str("&lt;");
-        for lifetime in last.lifetimes.iter() {
-            if counter > 0 { generics.push_str(", "); }
-            counter += 1;
-            generics.push_str(format!("{}", *lifetime).as_slice());
-        }
-        for ty in last.types.iter() {
-            if counter > 0 { generics.push_str(", "); }
-            counter += 1;
-            generics.push_str(format!("{}", *ty).as_slice());
-        }
-        generics.push_str("&gt;");
-    }
+    let generics = format!("{}", last.params);
 
     let loc = CURRENT_LOCATION_KEY.with(|l| l.borrow().clone());
     let cache = cache();
@@ -660,8 +677,10 @@ impl fmt::Show for clean::ViewListIdent {
                     global: false,
                     segments: vec!(clean::PathSegment {
                         name: self.name.clone(),
-                        lifetimes: Vec::new(),
-                        types: Vec::new(),
+                        params: clean::PathParameters::AngleBracketed {
+                            lifetimes: Vec::new(),
+                            types: Vec::new(),
+                        }
                     })
                 };
                 resolved_path(f, did, &path, false)