Add check for presence of signature in alias declarations.

kraigher · kraigher · commit 56ad8d12b6c9 · 2020-01-12T19:41:18.000+01:00
diff --git a/vhdl_lang/src/analysis/declarative.rs b/vhdl_lang/src/analysis/declarative.rs
@@ -124,22 +124,31 @@ impl<'a> AnalyzeContext<'a> {
                     if subtype_indication.is_some() {
                         NamedEntityKind::OtherAlias
                     } else {
-                        let named_entity = if signature.is_some() {
-                            // @TODO use signature to select named entity
-                            resolved_name
-                                .and_then(|resolved| resolved.into_known())
-                                .map(|entities| entities.first().clone())
-                        } else {
-                            resolved_name.and_then(|resolved| resolved.into_non_overloaded())
-                        };
+                        if let Some(named_entities) =
+                            resolved_name.and_then(|name| name.into_known())
+                        {
+                            let ent = match named_entities {
+                                NamedEntities::Single(ent) => {
+                                    if let Some(signature) = signature {
+                                        diagnostics.error(signature, "Alias should only have a signature for subprograms and enum literals");
+                                    }
+                                    ent
+                                }
+                                NamedEntities::Overloaded(overloaded) => {
+                                    if signature.is_none() {
+                                        diagnostics.error(name, "Signature required for alias of subprogram and enum literals");
+                                    }
+                                    // @TODO use signature to determine variant
+                                    overloaded.first().clone()
+                                }
+                            };
 
-                        if let Some(named_entity) = named_entity {
                             region.add_implicit_declaration_aliases(
                                 Some(&designator.pos),
-                                &named_entity,
+                                &ent,
                                 diagnostics,
                             );
-                            NamedEntityKind::AliasOf(named_entity)
+                            NamedEntityKind::AliasOf(ent)
                         } else {
                             NamedEntityKind::OtherAlias
                         }
@@ -505,10 +514,10 @@ impl<'a> AnalyzeContext<'a> {
     pub fn analyze_signature(
         &self,
         region: &Region<'_>,
-        signature: &mut Signature,
+        signature: &mut WithPos<Signature>,
         diagnostics: &mut dyn DiagnosticHandler,
     ) -> FatalNullResult {
-        match signature {
+        match &mut signature.item {
             Signature::Function(ref mut args, ref mut ret) => {
                 for arg in args.iter_mut() {
                     if let Err(err) = self.resolve_selected_name(region, arg) {
diff --git a/vhdl_lang/src/analysis/tests/resolves_names.rs b/vhdl_lang/src/analysis/tests/resolves_names.rs
@@ -1061,7 +1061,7 @@ begin
   blk: block (ent_in = 1) is
     generic( gen : integer := 0 );
     generic map ( gen => 1);
-    port( 
+    port(
       prt_in : in integer := 0;
       prt_out : out integer := 0
     );
@@ -1076,3 +1076,55 @@ end architecture;
 ",
     );
 }
+
+#[test]
+fn error_on_signature_for_non_overloaded_alias() {
+    let mut builder = LibraryBuilder::new();
+    let code = builder.code(
+        "libname",
+        "
+package pkg is
+  type enum_t is (alpha, beta);
+  alias alias_t is enum_t[return integer];
+end package;
+",
+    );
+
+    let diagnostics = builder.analyze();
+    check_diagnostics(
+        diagnostics,
+        vec![Diagnostic::error(
+            code.s1("[return integer]"),
+            "Alias should only have a signature for subprograms and enum literals",
+        )],
+    );
+}
+
+#[test]
+fn error_on_non_signature_for_overloaded_alias() {
+    let mut builder = LibraryBuilder::new();
+    let code = builder.code(
+        "libname",
+        "
+package pkg is
+end package;
+
+package body pkg is
+  procedure subpgm(arg: natural) is
+  begin
+  end;
+
+  alias alias_t is subpgm;
+end package body;
+",
+    );
+
+    let diagnostics = builder.analyze();
+    check_diagnostics(
+        diagnostics,
+        vec![Diagnostic::error(
+            code.s("subpgm", 2),
+            "Signature required for alias of subprogram and enum literals",
+        )],
+    );
+}
diff --git a/vhdl_lang/src/ast.rs b/vhdl_lang/src/ast.rs
@@ -99,7 +99,7 @@ pub enum Binary {
 #[derive(PartialEq, Debug, Clone)]
 pub struct AttributeName {
     pub name: WithPos<Name>,
-    pub signature: Option<Signature>,
+    pub signature: Option<WithPos<Signature>>,
     pub attr: Ident,
     pub expr: Option<Box<WithPos<Expression>>>,
 }
@@ -381,7 +381,7 @@ pub struct AliasDeclaration {
     pub designator: WithPos<Designator>,
     pub subtype_indication: Option<SubtypeIndication>,
     pub name: WithPos<Name>,
-    pub signature: Option<Signature>,
+    pub signature: Option<WithPos<Signature>>,
 }
 
 /// LRM 6.7 Attribute declarations
@@ -395,7 +395,7 @@ pub struct AttributeDeclaration {
 #[derive(PartialEq, Debug, Clone)]
 pub struct EntityTag {
     pub designator: WithPos<Designator>,
-    pub signature: Option<Signature>,
+    pub signature: Option<WithPos<Signature>>,
 }
 
 /// LRM 7.2 Attribute specification
diff --git a/vhdl_lang/src/ast/search.rs b/vhdl_lang/src/ast/search.rs
@@ -828,7 +828,9 @@ impl Search for Declaration {
                 return_if_found!(searcher.search_decl_pos(&designator.pos).or_not_found());
                 return_if_found!(subtype_indication.search(searcher));
                 return_if_found!(name.search(searcher));
-                return_if_found!(signature.search(searcher));
+                if let Some(signature) = signature {
+                    return_if_found!(signature.item.search(searcher));
+                }
             }
             Declaration::Use(use_clause) => return_if_found!(searcher
                 .search_with_pos(&use_clause.pos)
diff --git a/vhdl_lang/src/syntax/names.rs b/vhdl_lang/src/syntax/names.rs
@@ -191,7 +191,7 @@ fn parse_function_call(
 fn parse_attribute_name(
     stream: &mut TokenStream,
     name: WithPos<Name>,
-    signature: Option<Signature>,
+    signature: Option<WithPos<Signature>>,
 ) -> ParseResult<WithPos<Name>> {
     let attr = stream.expect_ident_or_range()?;
 
diff --git a/vhdl_lang/src/syntax/subprogram.rs b/vhdl_lang/src/syntax/subprogram.rs
@@ -13,12 +13,14 @@ use super::tokens::{Kind::*, TokenStream};
 use crate::ast::*;
 use crate::data::*;
 
-pub fn parse_signature(stream: &mut TokenStream) -> ParseResult<Signature> {
-    stream.expect_kind(LeftSquare)?;
+pub fn parse_signature(stream: &mut TokenStream) -> ParseResult<WithPos<Signature>> {
+    let left_square = stream.expect_kind(LeftSquare)?;
+    let start_pos = left_square.pos;
     let mut type_marks = Vec::new();
     let mut return_mark = None;
     let mut errmsg = None;
-    loop {
+
+    let pos = loop {
         let token = stream.peek_expect()?;
 
         try_token_kind!(
@@ -32,7 +34,7 @@ pub fn parse_signature(stream: &mut TokenStream) -> ParseResult<Signature> {
                     sep_token,
                     Comma => {},
                     RightSquare => {
-                        break;
+                        break start_pos.combine(&sep_token.pos);
                     },
                     Return => {
                         let new_return_mark = Some(parse_selected_name(stream)?);
@@ -55,19 +57,22 @@ pub fn parse_signature(stream: &mut TokenStream) -> ParseResult<Signature> {
             },
             RightSquare => {
                 stream.move_after(&token);
-                break;
+                break start_pos.combine(&token.pos);
             }
         )
-    }
+    };
+
     if let Some(diagnostic) = errmsg {
         // @TODO recoverable error should not return Err
         return Err(diagnostic);
     }
 
-    Ok(match return_mark {
+    let signature = match return_mark {
         Some(return_mark) => Signature::Function(type_marks, return_mark),
         None => Signature::Procedure(type_marks),
-    })
+    };
+
+    Ok(WithPos::new(signature, pos))
 }
 
 fn parse_designator(stream: &mut TokenStream) -> ParseResult<WithPos<SubprogramDesignator>> {
@@ -316,7 +321,10 @@ function foo(foo : natural) return lib.foo.natural;
         let code = Code::new("[return bar.type_mark]");
         assert_eq!(
             code.with_stream(parse_signature),
-            Signature::Function(vec![], code.s1("bar.type_mark").selected_name())
+            WithPos::new(
+                Signature::Function(vec![], code.s1("bar.type_mark").selected_name()),
+                code.pos()
+            )
         );
     }
 
@@ -325,9 +333,12 @@ function foo(foo : natural) return lib.foo.natural;
         let code = Code::new("[foo.type_mark return bar.type_mark]");
         assert_eq!(
             code.with_stream(parse_signature),
-            Signature::Function(
-                vec![code.s1("foo.type_mark").selected_name()],
-                code.s1("bar.type_mark").selected_name()
+            WithPos::new(
+                Signature::Function(
+                    vec![code.s1("foo.type_mark").selected_name()],
+                    code.s1("bar.type_mark").selected_name()
+                ),
+                code.pos()
             )
         );
     }
@@ -337,7 +348,10 @@ function foo(foo : natural) return lib.foo.natural;
         let code = Code::new("[foo.type_mark]");
         assert_eq!(
             code.with_stream(parse_signature),
-            Signature::Procedure(vec![code.s1("foo.type_mark").selected_name()])
+            WithPos::new(
+                Signature::Procedure(vec![code.s1("foo.type_mark").selected_name()]),
+                code.pos()
+            )
         );
     }
 
@@ -346,12 +360,15 @@ function foo(foo : natural) return lib.foo.natural;
         let code = Code::new("[foo.type_mark, foo2.type_mark return bar.type_mark]");
         assert_eq!(
             code.with_stream(parse_signature),
-            Signature::Function(
-                vec![
-                    code.s1("foo.type_mark").selected_name(),
-                    code.s1("foo2.type_mark").selected_name()
-                ],
-                code.s1("bar.type_mark").selected_name()
+            WithPos::new(
+                Signature::Function(
+                    vec![
+                        code.s1("foo.type_mark").selected_name(),
+                        code.s1("foo2.type_mark").selected_name()
+                    ],
+                    code.s1("bar.type_mark").selected_name()
+                ),
+                code.pos()
             )
         );
     }
diff --git a/vhdl_lang/src/syntax/test.rs b/vhdl_lang/src/syntax/test.rs
@@ -325,7 +325,7 @@ impl Code {
         self.parse_ok(parse_selected_name)
     }
 
-    pub fn signature(&self) -> Signature {
+    pub fn signature(&self) -> WithPos<Signature> {
         self.parse_ok(parse_signature)
     }
 

Original file line number	Diff line number	Diff line change
`@@ -325,7 +325,7 @@ impl Code {`
`325`	`325`	`self.parse_ok(parse_selected_name)`
`326`	`326`	`}`
`327`	`327`
`328`		`- pub fn signature(&self) -> Signature {`
	`328`	`+ pub fn signature(&self) -> WithPos<Signature> {`
`329`	`329`	`self.parse_ok(parse_signature)`
`330`	`330`	`}`
`331`	`331`