Use FromIterator for NameAddr construction (#1199)

If we provide a `FromIterator` implementation for `NameAddr`, we need
not have an extra import to construct `NameAddr`s when the type is
known.

No functional changes.

Author: olix0r

linkerd/app/core/src/addr_match.rs

@@ -1,7 +1,7 @@
 use ipnet::IpNet;
 use linkerd_addr::Addr;
 use linkerd_dns::{Name, Suffix};
-use std::{fmt, net::IpAddr, sync::Arc};
+use std::{fmt, iter::FromIterator, net::IpAddr, sync::Arc};
 
 #[derive(Clone, Debug, Default)]
 pub struct AddrMatch {
@@ -23,7 +23,7 @@ impl AddrMatch {
         nets: impl IntoIterator<Item = IpNet>,
     ) -> Self {
         Self {
-            names: NameMatch::new(suffixes),
+            names: suffixes.into_iter().collect(),
             nets: IpMatch::new(nets),
         }
     }
@@ -54,7 +54,7 @@ impl From<IpMatch> for AddrMatch {
     fn from(nets: IpMatch) -> Self {
         Self {
             nets,
-            names: NameMatch::new(None),
+            names: NameMatch::default(),
         }
     }
 }
@@ -74,19 +74,21 @@ impl From<AddrMatch> for IpMatch {
     }
 }
 
+// === impl NameMatch ===
+
 impl From<AddrMatch> for NameMatch {
     fn from(addrs: AddrMatch) -> Self {
         addrs.names
     }
 }
 
-// === impl NameMatch ===
-
-impl NameMatch {
-    pub fn new(suffixes: impl IntoIterator<Item = Suffix>) -> Self {
-        Self(Arc::new(suffixes.into_iter().collect()))
+impl FromIterator<Suffix> for NameMatch {
+    fn from_iter<T: IntoIterator<Item = Suffix>>(iter: T) -> Self {
+        Self(Arc::new(iter.into_iter().collect()))
     }
+}
 
+impl NameMatch {
     #[inline]
     pub fn matches(&self, name: &Name) -> bool {
         self.0.iter().any(|sfx| sfx.contains(name))

linkerd/app/gateway/src/tests.rs

@@ -171,7 +171,9 @@ impl Test {
     }
 
     fn with_profile(mut self, profile: profiles::Receiver) -> Self {
-        let allow = NameMatch::new(Some(dns::Suffix::from_str(self.suffix).unwrap()));
+        let allow = Some(dns::Suffix::from_str(self.suffix).unwrap())
+            .into_iter()
+            .collect::<NameMatch>();
         if allow.matches(self.target.name()) {
             self.profile = Some(profile);
         }

linkerd/app/inbound/src/test_util.rs

@@ -9,7 +9,7 @@ use linkerd_app_core::{
         tap,
     },
     transport::{Keepalive, ListenAddr},
-    NameMatch, ProxyRuntime,
+    ProxyRuntime,
 };
 pub use linkerd_app_test as support;
 use linkerd_server_policy::{Authentication, Authorization, Protocol, ServerPolicy};
@@ -20,7 +20,7 @@ pub fn default_config() -> Config {
         .parse::<Suffix>()
         .expect("`svc.cluster.local.` suffix is definitely valid");
     Config {
-        allow_discovery: NameMatch::new(Some(cluster_local)),
+        allow_discovery: Some(cluster_local).into_iter().collect(),
         proxy: config::ProxyConfig {
             server: config::ServerConfig {
                 addr: ListenAddr(([0, 0, 0, 0], 0).into()),

linkerd/app/src/env.rs

@@ -5,7 +5,7 @@ use crate::core::{
     proxy::http::{h1, h2},
     tls,
     transport::{Keepalive, ListenAddr},
-    Addr, AddrMatch, Conditional, IpNet, NameMatch,
+    Addr, AddrMatch, Conditional, IpNet,
 };
 use crate::{dns, gateway, identity, inbound, oc_collector, outbound};
 use inbound::port_policies;
@@ -449,7 +449,7 @@ pub fn parse_config<S: Strings>(strings: &S) -> Result<super::Config, EnvError>
     };
 
     let gateway = gateway::Config {
-        allow_discovery: NameMatch::new(gateway_suffixes?.unwrap_or_default()),
+        allow_discovery: gateway_suffixes?.into_iter().flatten().collect(),
     };
 
     let inbound = {
@@ -570,7 +570,7 @@ pub fn parse_config<S: Strings>(strings: &S) -> Result<super::Config, EnvError>
         };
 
         inbound::Config {
-            allow_discovery: NameMatch::new(dst_profile_suffixes),
+            allow_discovery: dst_profile_suffixes.into_iter().collect(),
             proxy: ProxyConfig {
                 server,
                 connect,