Gate rustc-specific code under a feature

compiler/rustc_pattern_analysis/src/constructor.rs

@@ -266,6 +266,7 @@ pub struct IntRange {
 
 impl IntRange {
     /// Best effort; will not know that e.g. `255u8..` is a singleton.
+    #[cfg_attr(not(feature = "rustc"), allow(dead_code))]
     pub(crate) fn is_singleton(&self) -> bool {
         // Since `lo` and `hi` can't be the same `Infinity` and `plus_one` never changes from finite
         // to infinite, this correctly only detects ranges that contain exacly one `Finite(x)`.

compiler/rustc_pattern_analysis/src/lib.rs

@@ -1,31 +1,40 @@
 //! Analysis of patterns, notably match exhaustiveness checking.
 
 pub mod constructor;
+#[cfg(feature = "rustc")]
 pub mod errors;
+#[cfg(feature = "rustc")]
 pub(crate) mod lints;
 pub mod pat;
+#[cfg(feature = "rustc")]
 pub mod rustc;
 pub mod usefulness;
 
 #[macro_use]
 extern crate tracing;
+#[cfg(feature = "rustc")]
 #[macro_use]
 extern crate rustc_middle;
 
+#[cfg(feature = "rustc")]
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
 
 use std::fmt;
 
-use constructor::{Constructor, ConstructorSet};
-use lints::PatternColumn;
-use rustc_hir::HirId;
 use rustc_index::Idx;
+#[cfg(feature = "rustc")]
 use rustc_middle::ty::Ty;
-use usefulness::{compute_match_usefulness, ValidityConstraint};
 
-use crate::lints::{lint_nonexhaustive_missing_variants, lint_overlapping_range_endpoints};
+use crate::constructor::{Constructor, ConstructorSet};
+#[cfg(feature = "rustc")]
+use crate::lints::{
+    lint_nonexhaustive_missing_variants, lint_overlapping_range_endpoints, PatternColumn,
+};
 use crate::pat::DeconstructedPat;
+#[cfg(feature = "rustc")]
 use crate::rustc::RustcCtxt;
+#[cfg(feature = "rustc")]
+use crate::usefulness::{compute_match_usefulness, ValidityConstraint};
 
 pub trait MatchCx: Sized + Clone + fmt::Debug {
     type Ty: Copy + Clone + fmt::Debug; // FIXME: remove Copy
@@ -72,6 +81,7 @@ impl<'p, Cx: MatchCx> Copy for MatchArm<'p, Cx> {}
 
 /// The entrypoint for this crate. Computes whether a match is exhaustive and which of its arms are
 /// useful, and runs some lints.
+#[cfg(feature = "rustc")]
 pub fn analyze_match<'p, 'tcx>(
     cx: &RustcCtxt<'p, 'tcx>,
     arms: &[rustc::MatchArm<'p, 'tcx>],

compiler/rustc_pattern_analysis/src/usefulness.rs

@@ -578,6 +578,7 @@ pub(crate) struct PatCtxt<'a, 'p, Cx: MatchCx> {
 
 impl<'a, 'p, Cx: MatchCx> PatCtxt<'a, 'p, Cx> {
     /// A `PatCtxt` when code other than `is_useful` needs one.
+    #[cfg_attr(not(feature = "rustc"), allow(dead_code))]
     pub(crate) fn new_dummy(
         cx: &'a Cx,
         ty: Cx::Ty,
@@ -601,7 +602,7 @@ impl<'a, 'p, Cx: MatchCx> fmt::Debug for PatCtxt<'a, 'p, Cx> {
 /// - in the matrix, track whether a given place (aka column) is known to contain a valid value or
 ///     not.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub(crate) enum ValidityConstraint {
+pub enum ValidityConstraint {
     ValidOnly,
     MaybeInvalid,
     /// Option for backwards compatibility: the place is not known to be valid but we allow omitting
@@ -610,7 +611,7 @@ pub(crate) enum ValidityConstraint {
 }
 
 impl ValidityConstraint {
-    pub(crate) fn from_bool(is_valid_only: bool) -> Self {
+    pub fn from_bool(is_valid_only: bool) -> Self {
         if is_valid_only { ValidOnly } else { MaybeInvalid }
     }
 
@@ -1296,7 +1297,7 @@ pub struct UsefulnessReport<'p, Cx: MatchCx> {
 
 /// Computes whether a match is exhaustive and which of its arms are useful.
 #[instrument(skip(cx, arms, wildcard_arena), level = "debug")]
-pub(crate) fn compute_match_usefulness<'p, Cx: MatchCx>(
+pub fn compute_match_usefulness<'p, Cx: MatchCx>(
     cx: &Cx,
     arms: &[MatchArm<'p, Cx>],
     scrut_ty: Cx::Ty,