Feature/error pythonic import

CHANGELOG.md

@@ -21,6 +21,24 @@
   the source of the problem.
   ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
 
+- Gleam will now emit a helpful message when attempting to import modules using
+  `.` instead of `/`.
+
+  ```gleam
+  error: Syntax error
+    ┌─ /src/parse/error.gleam:1:11
+    │
+  1 │ import one.two.three
+    │           ^ I was expecting either `/` or `.{` here.
+
+  Perhaps you meant one of:
+
+      import one/two
+      import one.{item}
+  ```
+
+  ([Zij-IT](https://github.com/zij-it))
+
 ### Build tool
 
 - `gleam update`, `gleam deps update`, and `gleam deps download` will now print

compiler-core/src/parse.rs

@@ -2706,7 +2706,7 @@ where
     fn parse_import(&mut self, import_start: u32) -> Result<Option<UntypedDefinition>, ParseError> {
         let mut start = 0;
         let mut end;
-        let mut module = String::new();
+        let mut module = EcoString::new();
         // Gather module names
         loop {
             let (s, name, e) = self.expect_name()?;
@@ -2741,8 +2741,32 @@ where
         let mut unqualified_values = vec![];
         let mut unqualified_types = vec![];
 
-        if self.maybe_one(&Token::Dot).is_some() {
-            let _ = self.expect_one(&Token::LeftBrace)?;
+        if let Some((dot_start, dot_end)) = self.maybe_one(&Token::Dot) {
+            if let Err(e) = self.expect_one(&Token::LeftBrace) {
+                // If the module does contain a '/', then it's unlikely that the user
+                // intended for the import to be pythonic, so skip this.
+                if module.contains('/') {
+                    return Err(e);
+                }
+
+                // Catch `import gleam.io` and provide a more helpful error...
+                let ParseErrorType::UnexpectedToken {
+                    token: Token::Name { name } | Token::UpName { name },
+                    ..
+                } = &e.error
+                else {
+                    return Err(e);
+                };
+
+                return Err(ParseError {
+                    error: ParseErrorType::IncorrectImportModuleSeparator {
+                        module,
+                        item: name.clone(),
+                    },
+                    location: SrcSpan::new(dot_start, dot_end),
+                });
+            };
+
             let parsed = self.parse_unqualified_imports()?;
             unqualified_types = parsed.types;
             unqualified_values = parsed.values;
@@ -2773,7 +2797,7 @@ where
             },
             unqualified_values,
             unqualified_types,
-            module: module.into(),
+            module,
             as_name,
             package: (),
         })))

compiler-core/src/parse/error.rs

@@ -338,6 +338,15 @@ utf16_codepoint, utf32_codepoint, signed, unsigned, big, little, native, size, u
                 "This attribute cannot be used on a variant.",
                 vec!["Hint: Did you mean `@deprecated`?".into()],
             ),
+            ParseErrorType::IncorrectImportModuleSeparator { module, item } => (
+                "I was expecting either `/` or `.{` here.",
+                vec![
+                    "Perhaps you meant one of:".into(),
+                    "".into(),
+                    format!("    import {module}/{item}"),
+                    format!("    import {module}.{{item}}"),
+                ]
+            )
         }
     }
 }
@@ -411,6 +420,11 @@ pub enum ParseErrorType {
     TypeConstructorNoArguments,           // let a : Int()
     TypeDefinitionNoArguments,            // pub type Wibble() { ... }
     UnknownAttributeRecordVariant, // an attribute was used that is not know for a custom type variant
+    // a Python-like import was written, such as `import gleam.io`, instead of `import gleam/io`
+    IncorrectImportModuleSeparator {
+        module: EcoString,
+        item: EcoString,
+    },
 }
 
 impl LexicalError {

compiler-core/src/parse/snapshots/gleam_core__parse__tests__doesnt_issue_special_error_for_pythonic_import_if_slash.snap

@@ -0,0 +1,16 @@
+---
+source: compiler-core/src/parse/tests.rs
+expression: import one/two.three
+---
+----- SOURCE CODE
+import one/two.three
+
+----- ERROR
+error: Syntax error
+  ┌─ /src/parse/error.gleam:1:16
+  │
+1 │ import one/two.three
+  │                ^^^^^ I was not expecting this
+
+Found a name, expected one of: 
+- `{`

compiler-core/src/parse/snapshots/gleam_core__parse__tests__special_error_for_pythonic_import.snap

@@ -0,0 +1,20 @@
+---
+source: compiler-core/src/parse/tests.rs
+assertion_line: 1792
+expression: import gleam.io
+snapshot_kind: text
+---
+----- SOURCE CODE
+import gleam.io
+
+----- ERROR
+error: Syntax error
+  ┌─ /src/parse/error.gleam:1:13
+  │
+1 │ import gleam.io
+  │             ^ I was expecting either `/` or `.{` here.
+
+Perhaps you meant one of:
+
+    import gleam/io
+    import gleam.{item}

compiler-core/src/parse/snapshots/gleam_core__parse__tests__special_error_for_pythonic_neste_import.snap

@@ -0,0 +1,20 @@
+---
+source: compiler-core/src/parse/tests.rs
+assertion_line: 1797
+expression: import one.two.three
+snapshot_kind: text
+---
+----- SOURCE CODE
+import one.two.three
+
+----- ERROR
+error: Syntax error
+  ┌─ /src/parse/error.gleam:1:11
+  │
+1 │ import one.two.three
+  │           ^ I was expecting either `/` or `.{` here.
+
+Perhaps you meant one of:
+
+    import one/two
+    import one.{item}

compiler-core/src/parse/tests.rs

@@ -1786,3 +1786,18 @@ fn assert_statement_without_expression() {
 fn assert_statement_followed_by_statement() {
     assert_error!("assert let a = 10");
 }
+
+#[test]
+fn special_error_for_pythonic_import() {
+    assert_module_error!("import gleam.io");
+}
+
+#[test]
+fn special_error_for_pythonic_neste_import() {
+    assert_module_error!("import one.two.three");
+}
+
+#[test]
+fn doesnt_issue_special_error_for_pythonic_import_if_slash() {
+    assert_module_error!("import one/two.three");
+}