Address review comments.

Author: crlf0710

src/librustc/middle/cstore.rs

@@ -96,7 +96,7 @@ pub enum NativeLibraryKind {
     NativeStaticNobundle,
     /// macOS-specific
     NativeFramework,
-    /// windows dynamic library without import library
+    /// Windows dynamic library without import library.
     NativeRawDylib,
     /// default way to specify a dynamic library
     NativeUnknown,

src/librustc_metadata/native_libs.rs

@@ -176,7 +176,7 @@ impl Collector<'tcx> {
                                            sym::raw_dylib,
                                            span.unwrap_or_else(|| syntax_pos::DUMMY_SP),
                                            GateIssue::Language,
-                                           "kind=\"raw-dylib\" is feature gated");
+                                           "kind=\"raw-dylib\" is unstable");
         }
         self.libs.push(lib);
     }

src/librustc_typeck/collect.rs

@@ -2642,33 +2642,8 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, id: DefId) -> CodegenFnAttrs {
         } else if attr.check_name(sym::link_name) {
             codegen_fn_attrs.link_name = attr.value_str();
         } else if attr.check_name(sym::link_ordinal) {
-            use syntax::ast::{Lit, LitIntType, LitKind};
-            let meta_item_list = attr.meta_item_list();
-            let sole_meta_lit = if let Some(meta_item_list) = &meta_item_list {
-                if meta_item_list.len() == 1 {
-                    meta_item_list.get(0).and_then(|item| item.literal())
-                } else {
-                    None
-                }
-            } else {
-                None
-            };
-            if let Some(Lit { node: LitKind::Int(ordinal, LitIntType::Unsuffixed), .. }) =
-                sole_meta_lit
-            {
-                if *ordinal <= std::usize::MAX as u128 {
-                    codegen_fn_attrs.link_ordinal = Some(*ordinal as usize);
-                } else {
-                    let msg = format!(
-                        "too large ordinal value in link_ordinal \
-                         value: `{}`",
-                        &ordinal
-                    );
-                    tcx.sess.span_err(attr.span, &msg);
-                }
-            } else {
-                let msg = "illegal ordinal format in link_ordinal";
-                tcx.sess.span_err(attr.span, &msg);
+            if let ordinal @ Some(_) = check_link_ordinal(tcx, attr) {
+                codegen_fn_attrs.link_ordinal = ordinal;
             }
         }
     }
@@ -2747,6 +2722,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, id: DefId) -> CodegenFnAttrs {
     // purpose functions as they wouldn't have the right target features
     // enabled. For that reason we also forbid #[inline(always)] as it can't be
     // respected.
+
     if codegen_fn_attrs.target_features.len() > 0 {
         if codegen_fn_attrs.inline == InlineAttr::Always {
             if let Some(span) = inline_span {
@@ -2771,15 +2747,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, id: DefId) -> CodegenFnAttrs {
         codegen_fn_attrs.export_name = Some(name);
         codegen_fn_attrs.link_name = Some(name);
     }
-    if codegen_fn_attrs.link_name.is_some() && codegen_fn_attrs.link_ordinal.is_some() {
-        if let Some(span) = inline_span {
-            tcx.sess.span_err(
-                span,
-                "cannot use `#[link_name]` with \
-                 `#[link_ordinal]`",
-            );
-        }
-    }
+    check_link_name_xor_ordinal(tcx, &codegen_fn_attrs, inline_span);
 
     // Internal symbols to the standard library all have no_mangle semantics in
     // that they have defined symbol names present in the function name. This
@@ -2790,3 +2758,44 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, id: DefId) -> CodegenFnAttrs {
 
     codegen_fn_attrs
 }
+
+fn check_link_ordinal(tcx: TyCtxt<'_>, attr: &ast::Attribute) -> Option<usize> {
+    use syntax::ast::{Lit, LitIntType, LitKind};
+    let meta_item_list = attr.meta_item_list();
+    let meta_item_list: Option<&[ast::NestedMetaItem]> = meta_item_list.as_ref().map(Vec::as_ref);
+    let sole_meta_list = match meta_item_list {
+        Some([item]) => item.literal(),
+        _ => None,
+    };
+    if let Some(Lit { node: LitKind::Int(ordinal, LitIntType::Unsuffixed), .. }) = sole_meta_list {
+        if *ordinal <= std::usize::MAX as u128 {
+            Some(*ordinal as usize)
+        } else {
+            let msg = format!(
+                "too large ordinal value in link_ordinal value: `{}`",
+                &ordinal
+            );
+            tcx.sess.span_err(attr.span, &msg);
+            None
+        }
+    } else {
+        tcx.sess.span_err(attr.span, "illegal ordinal format in link_ordinal");
+        None
+    }
+}
+
+fn check_link_name_xor_ordinal(
+    tcx: TyCtxt<'_>,
+    codegen_fn_attrs: &CodegenFnAttrs,
+    inline_span: Option<Span>,
+) {
+    if codegen_fn_attrs.link_name.is_none() || codegen_fn_attrs.link_ordinal.is_none() {
+        return;
+    }
+    let msg = "cannot use `#[link_name]` with `#[link_ordinal]`";
+    if let Some(span) = inline_span {
+        tcx.sess.span_err(span, msg);
+    } else {
+        tcx.sess.err(msg);
+    }
+}

src/libsyntax/feature_gate/active.rs

@@ -539,4 +539,5 @@ pub const INCOMPLETE_FEATURES: &[Symbol] = &[
     sym::const_generics,
     sym::or_patterns,
     sym::let_chains,
+    sym::raw_dylib,
 ];

src/libsyntax/feature_gate/builtin_attrs.rs

@@ -277,12 +277,10 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         it is recommended to use `#[link(name = \"foo\")] instead",
     ),
     gated!(
-        link_ordinal,
-        Whitelisted,
-        template!(List: "ordinal"),
-        raw_dylib,
+        link_ordinal, Whitelisted, template!(List: "ordinal"), raw_dylib,
         experimental!(link_ordinal)
     ),
+
     // Plugins:
     (
         sym::plugin_registrar, Normal, template!(Word),

src/test/ui/feature-gates/feature-gate-raw-dylib-2.rs

@@ -0,0 +1,8 @@
+#[link(name="foo")]
+extern {
+    #[link_ordinal(42)]
+    //~^ ERROR: the `#[link_ordinal]` attribute is an experimental feature
+    fn foo();
+}
+
+fn main() {}

src/test/ui/rfc-2627-raw-dylib/feature-gate-raw-dylib-2.rs

@@ -1,8 +1,8 @@
 error[E0658]: the `#[link_ordinal]` attribute is an experimental feature
-  --> $DIR/feature-gate-raw-dylib-2.rs:3:1
+  --> $DIR/feature-gate-raw-dylib-2.rs:3:5
    |
-LL | #[link_ordinal(42)]
-   | ^^^^^^^^^^^^^^^^^^^
+LL |     #[link_ordinal(42)]
+   |     ^^^^^^^^^^^^^^^^^^^
    |
    = note: for more information, see https://github.com/rust-lang/rust/issues/58713
    = help: add `#![feature(raw_dylib)]` to the crate attributes to enable

src/test/ui/feature-gates/feature-gate-raw-dylib-2.stderr renamed to src/test/ui/rfc-2627-raw-dylib/feature-gate-raw-dylib-2.stderr

@@ -1,5 +1,5 @@
 #[link(name="foo", kind="raw-dylib")]
-//~^ ERROR: kind="raw-dylib" is feature gated
+//~^ ERROR: kind="raw-dylib" is unstable
 extern {}
 
 fn main() {}

src/test/ui/feature-gates/feature-gate-raw-dylib.rs renamed to src/test/ui/rfc-2627-raw-dylib/feature-gate-raw-dylib.rs

@@ -1,4 +1,4 @@
-error[E0658]: kind="raw-dylib" is feature gated
+error[E0658]: kind="raw-dylib" is unstable
   --> $DIR/feature-gate-raw-dylib.rs:1:1
    |
 LL | #[link(name="foo", kind="raw-dylib")]