use rustc::middle::expr_use_visitor::*;
use rustc::middle::mem_categorization::{cmt, Categorization};
use rustc::ty::{self, Ty};
+use rustc::ty::layout::LayoutOf;
use rustc::util::nodemap::NodeSet;
use syntax::ast::NodeId;
use syntax::codemap::Span;
-use utils::{span_lint, type_size};
+use utils::span_lint;
pub struct Pass {
pub too_large_for_stack: u64,
// Large types need to be boxed to avoid stack
// overflows.
if ty.is_box() {
- type_size(self.cx, ty.boxed_ty()).unwrap_or(0) > self.too_large_for_stack
+ self.cx.layout_of(ty.boxed_ty()).ok().map_or(0, |l| l.size.bytes()) > self.too_large_for_stack
} else {
false
}
use rustc::lint::*;
use rustc::hir::*;
-use utils::{snippet_opt, span_lint_and_then, type_size};
-use rustc::ty::TypeFoldable;
+use utils::{snippet_opt, span_lint_and_then};
+use rustc::ty::layout::LayoutOf;
/// **What it does:** Checks for large size differences between variants on
/// `enum`s.
let size: u64 = variant
.fields
.iter()
- .map(|f| {
+ .filter_map(|f| {
let ty = cx.tcx.type_of(f.did);
- if ty.needs_subst() {
- 0 // we can't reason about generics, so we treat them as zero sized
- } else {
- type_size(cx, ty).expect("size should be computable for concrete type")
- }
+ // don't count generics by filtering out everything
+ // that does not have a layout
+ cx.layout_of(ty).ok().map(|l| l.size.bytes())
})
.sum();
use rustc::hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
use rustc::lint::*;
use rustc::ty::{self, Ty, TyCtxt, TypeckTables};
+use rustc::ty::layout::LayoutOf;
use rustc::ty::subst::Substs;
use rustc_typeck::hir_ty_to_ty;
use std::cmp::Ordering;
use syntax::errors::DiagnosticBuilder;
use utils::{comparisons, higher, in_constant, in_external_macro, in_macro, last_path_segment, match_def_path, match_path,
multispan_sugg, opt_def_id, same_tys, snippet, snippet_opt, span_help_and_lint, span_lint,
- span_lint_and_sugg, span_lint_and_then, type_size};
+ span_lint_and_sugg, span_lint_and_then};
use utils::paths;
/// Handles all the linting of funky types
let pre_cast_ty = cx.tables.expr_ty(cast_exp);
let cast_ty = cx.tables.expr_ty(expr);
// if it's a cast from i32 to u32 wrapping will invalidate all these checks
- if type_size(cx, pre_cast_ty) == type_size(cx, cast_ty) {
+ if cx.layout_of(pre_cast_ty).ok().map(|l| l.size) == cx.layout_of(cast_ty).ok().map(|l| l.size) {
return None;
}
match pre_cast_ty.sty {
use rustc::session::Session;
use rustc::traits;
use rustc::ty::{self, Ty, TyCtxt};
-use rustc::ty::layout::LayoutOf;
use rustc_errors;
use std::borrow::Cow;
use std::env;
None
}
-pub fn type_size<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>) -> Option<u64> {
- cx.layout_of(ty)
- .ok()
- .map(|layout| layout.size.bytes())
-}
-
/// Returns true if the lint is allowed in the current context
///
/// Useful for skipping long running code when it's unnecessary