This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6769

another way of implementing the parent
AbandonedPublic

Authored by valentin.gatienbaron on Aug 28 2019, 7:37 AM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Summary

I would drop this or fold it into the parent depending on reviewers' opinion.

The problem is that byte literals can converted to slices implicitely,
and concat can work on slices and other things, and it's too much for
the typer to try to do both at the time. Providing a monomorphic version
of the concat method avoids having to write &byteliteral[..].

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

Diff 16329

rust/hg-core/src/filepatterns.rs

// filepatterns.rs // filepatterns.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Handling of Mercurial-specific patterns. //! Handling of Mercurial-specific patterns.
use crate::{ use crate::{
utils::{files::get_path_from_bytes, SliceExt}, utils::{concat, files::get_path_from_bytes, SliceExt},
LineNumber, PatternError, PatternFileError, LineNumber, PatternError, PatternFileError,
}; };
use lazy_static::lazy_static; use lazy_static::lazy_static;
use regex::bytes::{NoExpand, Regex}; use regex::bytes::{NoExpand, Regex};
use std::collections::HashMap; use std::collections::HashMap;
use std::fs::File; use std::fs::File;
use std::io::Read; use std::io::Read;
use std::vec::Vec; use std::vec::Vec;
return vec![]; return vec![];
} }
match syntax { match syntax {
PatternSyntax::Regexp => pattern.to_owned(), PatternSyntax::Regexp => pattern.to_owned(),
PatternSyntax::RelRegexp => { PatternSyntax::RelRegexp => {
if pattern[0] == b'^' { if pattern[0] == b'^' {
return pattern.to_owned(); return pattern.to_owned();
} }
[&b".*"[..], pattern].concat() concat(&[b".*", pattern])
} }
PatternSyntax::Path | PatternSyntax::RelPath => { PatternSyntax::Path | PatternSyntax::RelPath => {
if pattern == b"." { if pattern == b"." {
return vec![]; return vec![];
} }
[&escape_pattern(pattern), &b"(?:/|$)"[..]].concat() concat(&[&escape_pattern(pattern), b"(?:/|$)"])
} }
PatternSyntax::RootFiles => { PatternSyntax::RootFiles => {
let mut res = if pattern == b"." { let mut res = if pattern == b"." {
vec![] vec![]
} else { } else {
// Pattern is a directory name. // Pattern is a directory name.
[&escape_pattern(pattern), &b"/"[..]].concat() concat(&[&escape_pattern(pattern), b"/"])
}; };
// Anything after the pattern must be a non-directory. // Anything after the pattern must be a non-directory.
res.extend(b"[^/]+$"); res.extend(b"[^/]+$");
res res
} }
PatternSyntax::RelGlob => { PatternSyntax::RelGlob => {
let glob_re = glob_to_re(pattern); let glob_re = glob_to_re(pattern);
if let Some(rest) = glob_re.drop_prefix(b"[^/]*") { if let Some(rest) = glob_re.drop_prefix(b"[^/]*") {
[&b".*"[..], rest, globsuffix].concat() concat(&[b".*", rest, globsuffix])
} else { } else {
[&b"(?:|.*/)"[..], &glob_re, globsuffix].concat() concat(&[b"(?:|.*/)", &glob_re, globsuffix])
} }
} }
PatternSyntax::Glob PatternSyntax::Glob
| PatternSyntax::RootGlob => { | PatternSyntax::RootGlob => {
[&glob_to_re(pattern), globsuffix].concat() concat(&[&glob_to_re(pattern), globsuffix])
} }
} }
} }
const GLOB_SPECIAL_CHARACTERS: [u8; 7] = const GLOB_SPECIAL_CHARACTERS: [u8; 7] =
[b'*', b'?', b'[', b']', b'{', b'}', b'\\']; [b'*', b'?', b'[', b']', b'{', b'}', b'\\'];
/// Wrapper function to `_build_single_regex` that short-circuits 'exact' globs /// Wrapper function to `_build_single_regex` that short-circuits 'exact' globs

rust/hg-core/src/utils.rs

} }
for i in 0..=buf.len() - from.len() { for i in 0..=buf.len() - from.len() {
if buf[i..].starts_with(from) { if buf[i..].starts_with(from) {
buf[i..(i + from.len())].clone_from_slice(to); buf[i..(i + from.len())].clone_from_slice(to);
} }
} }
} }
pub fn concat(slices: &[&[u8]]) -> Vec<u8> {
slices.concat()
}
pub trait SliceExt { pub trait SliceExt {
fn trim_end(&self) -> &Self; fn trim_end(&self) -> &Self;
fn trim_start(&self) -> &Self; fn trim_start(&self) -> &Self;
fn trim(&self) -> &Self; fn trim(&self) -> &Self;
fn drop_prefix(&self, needle: &Self) -> Option<&Self>; fn drop_prefix(&self, needle: &Self) -> Option<&Self>;
} }
fn is_not_whitespace(c: &u8) -> bool { fn is_not_whitespace(c: &u8) -> bool {