Add default type hint for bytes

Author: njqdev

src/python.ts

@@ -27,6 +27,7 @@ export interface DataTypeContainer {
 export const getDataTypeContainer = (): DataTypeContainer => {
     return {
         bool: new DataType(PythonType.Bool, typeCategories.bool),
+        bytes: new DataType(PythonType.Bytes, typeCategories.bytes),
         complex: new DataType(PythonType.Complex, typeCategories.complex),
         dict: new DataType(PythonType.Dict, typeCategories.dict),
         float: new DataType(PythonType.Float, typeCategories.float),
@@ -44,6 +45,7 @@ export const getDataTypeContainer = (): DataTypeContainer => {
  */
 export enum PythonType {
     Bool = "bool",
+    Bytes = "bytes",
     Complex = "complex",
     Dict = "dict",
     Float = "float",
@@ -69,6 +71,7 @@ export enum TypeCategory {
  */
 const typeCategories: { [key: string]: TypeCategory } = {
     bool: TypeCategory.Basic,
+    bytes: TypeCategory.Basic,
     complex: TypeCategory.Basic,
     dict: TypeCategory.Collection,
     float: TypeCategory.Basic,

src/typeSearch.ts

@@ -130,6 +130,7 @@ export class TypeSearch {
             [ PythonType.Set, `${PythonType.Set}\\(`, `^ *{( *"[^"]*" *[},]+| *'[^']*' *[},]+|[^:]+[}])`],
             [ PythonType.Dict, `${PythonType.Dict}\\(`, "^ *{"],
             [ PythonType.String, `${PythonType.String}\\(`, `^ *(['"]{2}|(\\( *)?"[^"]*"|(\\( *)?'[^']*')`],
+            [ PythonType.Bytes, `${PythonType.Bytes}\\(`, `^ *b['"]`],
             [ PythonType.Int, `${PythonType.Int}\\(`, `^ *[-(]*[0-9]`],
             [ PythonType.Object, `${PythonType.Object}\\(` ]
         ];

test/suite/typeSearch/detection.test.ts

@@ -141,16 +141,37 @@ suite('TypeSearch.detectType', () => {
         actual = TypeSearch.detectType(src);
         assert.strictEqual(TypeSearch.detectType(src), expected, messageFor(src, expected, actual));
     });
+
+    test("detects bytes", async () => {
+        const expected = "bytes";
+
+        let src = "b'dont return string please'";
+        let actual = TypeSearch.detectType(src);
+        assert.strictEqual(actual, expected);
+
+        src = 'b"dont return string please"';
+        actual = TypeSearch.detectType(src);
+        assert.strictEqual(TypeSearch.detectType(src), expected, messageFor(src, expected, actual));
+
+        src = "b'''hi'''";
+        actual = TypeSearch.detectType(src);
+        assert.strictEqual(TypeSearch.detectType(src), expected, messageFor(src, expected, actual));
+
+        src = 'b"""hi"""';
+        actual = TypeSearch.detectType(src);
+        assert.strictEqual(TypeSearch.detectType(src), expected, messageFor(src, expected, actual));
+    });
 
     test("detects type() call", () => {
         const testCases: TestCase[] = [
-            { data: "int('2')", expected: "int"},
-            { data: "bool(true)", expected: "bool"},
-            { data: "list(foo)", expected: "list"},
-            { data: "dict(foo)", expected: "dict"},
-            { data: "tuple(foo)", expected: "tuple"},
-            { data: "str(1)", expected: "str"},
-            { data: "set([1])", expected: "set"}
+            { data: "int('2')", expected: "int" },
+            { data: "bool('true')", expected: "bool" },
+            { data: "list(foo)", expected: "list" },
+            { data: "dict(foo)", expected: "dict" },
+            { data: "tuple(foo)", expected: "tuple" },
+            { data: "str(1)", expected: "str" },
+            { data: "set([1])", expected: "set" },
+            { data: "bytes('hi', encoding='utf-8')", expected: "bytes" }
         ];
         for (const c of testCases) {
             let actual = TypeSearch.detectType(c.data);