@@ -76,7 +76,9 @@ use rustc_data_structures::sync::{FreezeLock, FreezeWriteGuard, Lock, Lrc};
7676
7777use std:: borrow:: Cow ;
7878use std:: cmp:: { self , Ordering } ;
79+ use std:: fmt:: Display ;
7980use std:: hash:: Hash ;
81+ use std:: io:: { self , Read } ;
8082use std:: ops:: { Add , Range , Sub } ;
8183use std:: path:: { Path , PathBuf } ;
8284use std:: str:: FromStr ;
@@ -1456,6 +1458,27 @@ pub enum SourceFileHashAlgorithm {
14561458 Md5 ,
14571459 Sha1 ,
14581460 Sha256 ,
1461+ Blake3 ,
1462+ }
1463+
1464+ impl SourceFileHashAlgorithm {
1465+ pub fn supported_in_cargo ( & self ) -> bool {
1466+ match self {
1467+ Self :: Md5 | Self :: Sha1 => false ,
1468+ Self :: Sha256 | Self :: Blake3 => true ,
1469+ }
1470+ }
1471+ }
1472+
1473+ impl Display for SourceFileHashAlgorithm {
1474+ fn fmt ( & self , f : & mut fmt:: Formatter < ' _ > ) -> fmt:: Result {
1475+ f. write_str ( match self {
1476+ Self :: Md5 => "md5" ,
1477+ Self :: Sha1 => "sha1" ,
1478+ Self :: Sha256 => "sha256" ,
1479+ Self :: Blake3 => "blake3" ,
1480+ } )
1481+ }
14591482}
14601483
14611484impl FromStr for SourceFileHashAlgorithm {
@@ -1466,25 +1489,36 @@ impl FromStr for SourceFileHashAlgorithm {
14661489 "md5" => Ok ( SourceFileHashAlgorithm :: Md5 ) ,
14671490 "sha1" => Ok ( SourceFileHashAlgorithm :: Sha1 ) ,
14681491 "sha256" => Ok ( SourceFileHashAlgorithm :: Sha256 ) ,
1492+ "blake3" => Ok ( SourceFileHashAlgorithm :: Blake3 ) ,
14691493 _ => Err ( ( ) ) ,
14701494 }
14711495 }
14721496}
14731497
1474- /// The hash of the on-disk source file used for debug info.
1498+ /// The hash of the on-disk source file used for debug info and cargo freshness checks .
14751499#[ derive( Copy , Clone , PartialEq , Eq , Debug , Hash ) ]
14761500#[ derive( HashStable_Generic , Encodable , Decodable ) ]
14771501pub struct SourceFileHash {
14781502 pub kind : SourceFileHashAlgorithm ,
14791503 value : [ u8 ; 32 ] ,
14801504}
14811505
1506+ impl Display for SourceFileHash {
1507+ fn fmt ( & self , f : & mut fmt:: Formatter < ' _ > ) -> fmt:: Result {
1508+ write ! ( f, "{}=" , self . kind) ?;
1509+ for byte in self . value [ 0 ..self . hash_len ( ) ] . into_iter ( ) {
1510+ write ! ( f, "{byte:02x}" ) ?;
1511+ }
1512+ Ok ( ( ) )
1513+ }
1514+ }
1515+
14821516impl SourceFileHash {
1483- pub fn new ( kind : SourceFileHashAlgorithm , src : & str ) -> SourceFileHash {
1517+ pub fn new_in_memory ( kind : SourceFileHashAlgorithm , src : impl AsRef < [ u8 ] > ) -> SourceFileHash {
14841518 let mut hash = SourceFileHash { kind, value : Default :: default ( ) } ;
14851519 let len = hash. hash_len ( ) ;
14861520 let value = & mut hash. value [ ..len] ;
1487- let data = src. as_bytes ( ) ;
1521+ let data = src. as_ref ( ) ;
14881522 match kind {
14891523 SourceFileHashAlgorithm :: Md5 => {
14901524 value. copy_from_slice ( & Md5 :: digest ( data) ) ;
@@ -1495,13 +1529,94 @@ impl SourceFileHash {
14951529 SourceFileHashAlgorithm :: Sha256 => {
14961530 value. copy_from_slice ( & Sha256 :: digest ( data) ) ;
14971531 }
1498- }
1532+ SourceFileHashAlgorithm :: Blake3 => value. copy_from_slice ( blake3:: hash ( data) . as_bytes ( ) ) ,
1533+ } ;
14991534 hash
15001535 }
15011536
1537+ pub fn new ( kind : SourceFileHashAlgorithm , src : impl Read ) -> Result < SourceFileHash , io:: Error > {
1538+ let mut hash = SourceFileHash { kind, value : Default :: default ( ) } ;
1539+ let len = hash. hash_len ( ) ;
1540+ let value = & mut hash. value [ ..len] ;
1541+ // Buffer size is the recommended amount to fully leverage SIMD instructions on AVX-512 as per
1542+ // blake3 documentation.
1543+ let mut buf = vec ! [ 0 ; 16 * 1024 ] ;
1544+
1545+ fn digest < T > (
1546+ mut hasher : T ,
1547+ mut update : impl FnMut ( & mut T , & [ u8 ] ) ,
1548+ finish : impl FnOnce ( T , & mut [ u8 ] ) ,
1549+ mut src : impl Read ,
1550+ buf : & mut [ u8 ] ,
1551+ value : & mut [ u8 ] ,
1552+ ) -> Result < ( ) , io:: Error > {
1553+ loop {
1554+ let bytes_read = src. read ( buf) ?;
1555+ if bytes_read == 0 {
1556+ break ;
1557+ }
1558+ update ( & mut hasher, & buf[ 0 ..bytes_read] ) ;
1559+ }
1560+ finish ( hasher, value) ;
1561+ Ok ( ( ) )
1562+ }
1563+
1564+ match kind {
1565+ SourceFileHashAlgorithm :: Sha256 => {
1566+ digest (
1567+ Sha256 :: new ( ) ,
1568+ |h, b| {
1569+ h. update ( b) ;
1570+ } ,
1571+ |h, out| out. copy_from_slice ( & h. finalize ( ) ) ,
1572+ src,
1573+ & mut buf,
1574+ value,
1575+ ) ?;
1576+ }
1577+ SourceFileHashAlgorithm :: Sha1 => {
1578+ digest (
1579+ Sha1 :: new ( ) ,
1580+ |h, b| {
1581+ h. update ( b) ;
1582+ } ,
1583+ |h, out| out. copy_from_slice ( & h. finalize ( ) ) ,
1584+ src,
1585+ & mut buf,
1586+ value,
1587+ ) ?;
1588+ }
1589+ SourceFileHashAlgorithm :: Md5 => {
1590+ digest (
1591+ Md5 :: new ( ) ,
1592+ |h, b| {
1593+ h. update ( b) ;
1594+ } ,
1595+ |h, out| out. copy_from_slice ( & h. finalize ( ) ) ,
1596+ src,
1597+ & mut buf,
1598+ value,
1599+ ) ?;
1600+ }
1601+ SourceFileHashAlgorithm :: Blake3 => {
1602+ digest (
1603+ blake3:: Hasher :: new ( ) ,
1604+ |h, b| {
1605+ h. update ( b) ;
1606+ } ,
1607+ |h, out| out. copy_from_slice ( h. finalize ( ) . as_bytes ( ) ) ,
1608+ src,
1609+ & mut buf,
1610+ value,
1611+ ) ?;
1612+ }
1613+ }
1614+ Ok ( hash)
1615+ }
1616+
15021617 /// Check if the stored hash matches the hash of the string.
15031618pub fn matches ( & self , src : & str ) -> bool {
1504- Self :: new ( self . kind , src) == * self
1619+ Self :: new_in_memory ( self . kind , src. as_bytes ( ) ) == * self
15051620 }
15061621
15071622 /// The bytes of the hash.
@@ -1514,7 +1629,7 @@ impl SourceFileHash {
15141629 match self . kind {
15151630 SourceFileHashAlgorithm :: Md5 => 16 ,
15161631 SourceFileHashAlgorithm :: Sha1 => 20 ,
1517- SourceFileHashAlgorithm :: Sha256 => 32 ,
1632+ SourceFileHashAlgorithm :: Sha256 | SourceFileHashAlgorithm :: Blake3 => 32 ,
15181633 }
15191634 }
15201635}
@@ -1570,6 +1685,10 @@ pub struct SourceFile {
15701685pub src : Option < Lrc < String > > ,
15711686 /// The source code's hash.
15721687pub src_hash : SourceFileHash ,
1688+ /// Used to enable cargo to use checksums to check if a crate is fresh rather
1689+ /// than mtimes. This might be the same as `src_hash`, and if the requested algorithm
1690+ /// is identical we won't compute it twice.
1691+ pub checksum_hash : Option < SourceFileHash > ,
15731692 /// The external source code (used for external crates, which will have a `None`
15741693/// value as `self.src`.
15751694pub external_src : FreezeLock < ExternalSource > ,
@@ -1599,6 +1718,7 @@ impl Clone for SourceFile {
15991718 name : self . name . clone ( ) ,
16001719 src : self . src . clone ( ) ,
16011720 src_hash : self . src_hash ,
1721+ checksum_hash : self . checksum_hash ,
16021722 external_src : self . external_src . clone ( ) ,
16031723 start_pos : self . start_pos ,
16041724 source_len : self . source_len ,
@@ -1616,6 +1736,7 @@ impl<S: SpanEncoder> Encodable<S> for SourceFile {
16161736 fn encode ( & self , s : & mut S ) {
16171737 self . name . encode ( s) ;
16181738 self . src_hash . encode ( s) ;
1739+ self . checksum_hash . encode ( s) ;
16191740 // Do not encode `start_pos` as it's global state for this session.
16201741 self . source_len . encode ( s) ;
16211742
@@ -1690,6 +1811,7 @@ impl<D: SpanDecoder> Decodable<D> for SourceFile {
16901811 fn decode ( d : & mut D ) -> SourceFile {
16911812 let name: FileName = Decodable :: decode ( d) ;
16921813 let src_hash: SourceFileHash = Decodable :: decode ( d) ;
1814+ let checksum_hash: Option < SourceFileHash > = Decodable :: decode ( d) ;
16931815 let source_len: RelativeBytePos = Decodable :: decode ( d) ;
16941816 let lines = {
16951817 let num_lines: u32 = Decodable :: decode ( d) ;
@@ -1716,6 +1838,7 @@ impl<D: SpanDecoder> Decodable<D> for SourceFile {
17161838 source_len,
17171839 src : None ,
17181840 src_hash,
1841+ checksum_hash,
17191842 // Unused - the metadata decoder will construct
17201843 // a new SourceFile, filling in `external_src` properly
17211844 external_src : FreezeLock :: frozen ( ExternalSource :: Unneeded ) ,
@@ -1800,9 +1923,17 @@ impl SourceFile {
18001923 name : FileName ,
18011924 mut src : String ,
18021925 hash_kind : SourceFileHashAlgorithm ,
1926+ checksum_hash_kind : Option < SourceFileHashAlgorithm > ,
18031927 ) -> Result < Self , OffsetOverflowError > {
18041928 // Compute the file hash before any normalization.
1805- let src_hash = SourceFileHash :: new ( hash_kind, & src) ;
1929+ let src_hash = SourceFileHash :: new_in_memory ( hash_kind, src. as_bytes ( ) ) ;
1930+ let checksum_hash = checksum_hash_kind. map ( |checksum_hash_kind| {
1931+ if checksum_hash_kind == hash_kind {
1932+ src_hash
1933+ } else {
1934+ SourceFileHash :: new_in_memory ( checksum_hash_kind, src. as_bytes ( ) )
1935+ }
1936+ } ) ;
18061937 let normalized_pos = normalize_src ( & mut src) ;
18071938
18081939 let stable_id = StableSourceFileId :: from_filename_in_current_crate ( & name) ;
@@ -1816,6 +1947,7 @@ impl SourceFile {
18161947 name,
18171948 src : Some ( Lrc :: new ( src) ) ,
18181949 src_hash,
1950+ checksum_hash,
18191951 external_src : FreezeLock :: frozen ( ExternalSource :: Unneeded ) ,
18201952 start_pos : BytePos :: from_u32 ( 0 ) ,
18211953 source_len : RelativeBytePos :: from_u32 ( source_len) ,
0 commit comments