prompt: We are currently solving the following issue within our repository. Here is the issue text:
  --- BEGIN ISSUE ---
  solc-version detector: Missing 0.5.11 
  `0.5.11` is incorrectly reported as an old version. 
  
  --- END ISSUE ---
  
  Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
  --- BEGIN FILES ---
  Path: `slither/detectors/attributes/incorrect_solc.py`
  Content:
  ```
  1 """
  2     Check if an incorrect version of solc is used
  3 """
  4 
  5 import re
  6 from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification
  7 from slither.formatters.attributes.incorrect_solc import format
  8 
  9 # group:
  10 # 0: ^ > >= < <= (optional)
  11 # 1: ' ' (optional)
  12 # 2: version number
  13 # 3: version number
  14 # 4: version number
  15 PATTERN = re.compile('(\^|>|>=|<|<=)?([ ]+)?(\d+)\.(\d+)\.(\d+)')
  16 
  17 class IncorrectSolc(AbstractDetector):
  18     """
  19     Check if an old version of solc is used
  20     """
  21 
  22     ARGUMENT = 'solc-version'
  23     HELP = 'Incorrect Solidity version (< 0.4.24 or complex pragma)'
  24     IMPACT = DetectorClassification.INFORMATIONAL
  25     CONFIDENCE = DetectorClassification.HIGH
  26 
  27     WIKI = 'https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-versions-of-solidity'
  28 
  29     WIKI_TITLE = 'Incorrect versions of Solidity'
  30     WIKI_DESCRIPTION = '''
  31 Solc frequently releases new compiler versions. Using an old version prevents access to new Solidity security checks.
  32 We recommend avoiding complex pragma statement.'''
  33     WIKI_RECOMMENDATION = '''
  34 Use Solidity 0.4.25 or 0.5.3. Consider using the latest version of Solidity for testing the compilation, and a trusted version for deploying.'''
  35 
  36     COMPLEX_PRAGMA_TXT = "is too complex"
  37     OLD_VERSION_TXT = "allows old versions"
  38     LESS_THAN_TXT = "uses lesser than"
  39 
  40     TOO_RECENT_VERSION_TXT = "necessitates versions too recent to be trusted. Consider deploying with 0.5.3"
  41     BUGGY_VERSION_TXT = "is known to contain severe issue (https://solidity.readthedocs.io/en/v0.5.8/bugs.html)"
  42 
  43     # Indicates the allowed versions.
  44     ALLOWED_VERSIONS = ["0.4.25", "0.4.26", "0.5.3"]
  45     # Indicates the versions too recent.
  46     TOO_RECENT_VERSIONS = ["0.5.4", "0.5.7", "0.5.8", "0.5.9", "0.5.10"]
  47     # Indicates the versions that should not be used.
  48     BUGGY_VERSIONS = ["0.4.22", "0.5.5", "0.5.6", "^0.4.22", "^0.5.5", "^0.5.6"]
  49 
  50     def _check_version(self, version):
  51         op = version[0]
  52         if op and not op in ['>', '>=', '^']:
  53             return self.LESS_THAN_TXT
  54         version_number = '.'.join(version[2:])
  55         if version_number not in self.ALLOWED_VERSIONS:
  56             if version_number in self.TOO_RECENT_VERSIONS:
  57                 return self.TOO_RECENT_VERSION_TXT
  58             return self.OLD_VERSION_TXT
  59         return None
  60 
  61     def _check_pragma(self, version):
  62         if version in self.BUGGY_VERSIONS:
  63             return self.BUGGY_VERSION_TXT
  64         versions = PATTERN.findall(version)
  65         if len(versions) == 1:
  66             version = versions[0]
  67             return self._check_version(version)
  68         elif len(versions) == 2:
  69             version_left = versions[0]
  70             version_right = versions[1]
  71             # Only allow two elements if the second one is
  72             # <0.5.0 or <0.6.0
  73             if version_right not in [('<', '', '0', '5', '0'), ('<', '', '0', '6', '0')]:
  74                 return self.COMPLEX_PRAGMA_TXT
  75             return self._check_version(version_left)
  76         else:
  77             return self.COMPLEX_PRAGMA_TXT
  78     def _detect(self):
  79         """
  80         Detects pragma statements that allow for outdated solc versions.
  81         :return: Returns the relevant JSON data for the findings.
  82         """
  83         # Detect all version related pragmas and check if they are disallowed.
  84         results = []
  85         pragma = self.slither.pragma_directives
  86         disallowed_pragmas = []
  87         detected_version = False
  88         for p in pragma:
  89             # Skip any pragma directives which do not refer to version
  90             if len(p.directive) < 1 or p.directive[0] != "solidity":
  91                 continue
  92 
  93             # This is version, so we test if this is disallowed.
  94             detected_version = True
  95             reason = self._check_pragma(p.version)
  96             if reason:
  97                 disallowed_pragmas.append((reason, p))
  98 
  99         # If we found any disallowed pragmas, we output our findings.
  100         if disallowed_pragmas:
  101             for (reason, p) in disallowed_pragmas:
  102                 info = f"Pragma version \"{p.version}\" {reason} ({p.source_mapping_str})\n"
  103 
  104                 json = self.generate_json_result(info)
  105                 self.add_pragma_to_json(p, json)
  106                 results.append(json)
  107 
  108         return results
  109 
  110     @staticmethod
  111     def _format(slither, result):
  112         format(slither, result)
  113
  ```
  --- END FILES ---
  
  Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.
  
  Here is an example:
  
  ```diff
  diff --git a/examples/server_async.py b/examples/server_async.py
  --- a/examples/server_async.py
  +++ b/examples/server_async.py
  @@ -313,4 +313,4 @@
   
   
   if __name__ == "__main__":
  -    asyncio.run(run_async_server("."), debug=True)
  +    asyncio.run(run_async_server(), debug=True)
  diff --git a/examples/server_sync.py b/examples/server_sync.py
  --- a/examples/server_sync.py
  +++ b/examples/server_sync.py
  @@ -313,5 +313,5 @@
   
   
   if __name__ == "__main__":
  -    server = run_sync_server(".")
  +    server = run_sync_server()
       server.shutdown()
  
  ```
  
golden_diff: diff --git a/slither/detectors/attributes/incorrect_solc.py b/slither/detectors/attributes/incorrect_solc.py
  --- a/slither/detectors/attributes/incorrect_solc.py
  +++ b/slither/detectors/attributes/incorrect_solc.py
  @@ -43,7 +43,7 @@
       # Indicates the allowed versions.
       ALLOWED_VERSIONS = ["0.4.25", "0.4.26", "0.5.3"]
       # Indicates the versions too recent.
  -    TOO_RECENT_VERSIONS = ["0.5.4", "0.5.7", "0.5.8", "0.5.9", "0.5.10"]
  +    TOO_RECENT_VERSIONS = ["0.5.4", "0.5.7", "0.5.8", "0.5.9", "0.5.10", "0.5.11"]
       # Indicates the versions that should not be used.
       BUGGY_VERSIONS = ["0.4.22", "0.5.5", "0.5.6", "^0.4.22", "^0.5.5", "^0.5.6"]
  
verification_info: {"golden_diff": "diff --git a/slither/detectors/attributes/incorrect_solc.py b/slither/detectors/attributes/incorrect_solc.py\n--- a/slither/detectors/attributes/incorrect_solc.py\n+++ b/slither/detectors/attributes/incorrect_solc.py\n@@ -43,7 +43,7 @@\n     # Indicates the allowed versions.\n     ALLOWED_VERSIONS = [\"0.4.25\", \"0.4.26\", \"0.5.3\"]\n     # Indicates the versions too recent.\n-    TOO_RECENT_VERSIONS = [\"0.5.4\", \"0.5.7\", \"0.5.8\", \"0.5.9\", \"0.5.10\"]\n+    TOO_RECENT_VERSIONS = [\"0.5.4\", \"0.5.7\", \"0.5.8\", \"0.5.9\", \"0.5.10\", \"0.5.11\"]\n     # Indicates the versions that should not be used.\n     BUGGY_VERSIONS = [\"0.4.22\", \"0.5.5\", \"0.5.6\", \"^0.4.22\", \"^0.5.5\", \"^0.5.6\"]\n", "issue": "solc-version detector: Missing 0.5.11 \n`0.5.11` is incorrectly reported as an old version. \n", "before_files": [{"content": "\"\"\"\n    Check if an incorrect version of solc is used\n\"\"\"\n\nimport re\nfrom slither.detectors.abstract_detector import AbstractDetector, DetectorClassification\nfrom slither.formatters.attributes.incorrect_solc import format\n\n# group:\n# 0: ^ > >= < <= (optional)\n# 1: ' ' (optional)\n# 2: version number\n# 3: version number\n# 4: version number\nPATTERN = re.compile('(\\^|>|>=|<|<=)?([ ]+)?(\\d+)\\.(\\d+)\\.(\\d+)')\n\nclass IncorrectSolc(AbstractDetector):\n    \"\"\"\n    Check if an old version of solc is used\n    \"\"\"\n\n    ARGUMENT = 'solc-version'\n    HELP = 'Incorrect Solidity version (< 0.4.24 or complex pragma)'\n    IMPACT = DetectorClassification.INFORMATIONAL\n    CONFIDENCE = DetectorClassification.HIGH\n\n    WIKI = 'https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-versions-of-solidity'\n\n    WIKI_TITLE = 'Incorrect versions of Solidity'\n    WIKI_DESCRIPTION = '''\nSolc frequently releases new compiler versions. Using an old version prevents access to new Solidity security checks.\nWe recommend avoiding complex pragma statement.'''\n    WIKI_RECOMMENDATION = '''\nUse Solidity 0.4.25 or 0.5.3. Consider using the latest version of Solidity for testing the compilation, and a trusted version for deploying.'''\n\n    COMPLEX_PRAGMA_TXT = \"is too complex\"\n    OLD_VERSION_TXT = \"allows old versions\"\n    LESS_THAN_TXT = \"uses lesser than\"\n\n    TOO_RECENT_VERSION_TXT = \"necessitates versions too recent to be trusted. Consider deploying with 0.5.3\"\n    BUGGY_VERSION_TXT = \"is known to contain severe issue (https://solidity.readthedocs.io/en/v0.5.8/bugs.html)\"\n\n    # Indicates the allowed versions.\n    ALLOWED_VERSIONS = [\"0.4.25\", \"0.4.26\", \"0.5.3\"]\n    # Indicates the versions too recent.\n    TOO_RECENT_VERSIONS = [\"0.5.4\", \"0.5.7\", \"0.5.8\", \"0.5.9\", \"0.5.10\"]\n    # Indicates the versions that should not be used.\n    BUGGY_VERSIONS = [\"0.4.22\", \"0.5.5\", \"0.5.6\", \"^0.4.22\", \"^0.5.5\", \"^0.5.6\"]\n\n    def _check_version(self, version):\n        op = version[0]\n        if op and not op in ['>', '>=', '^']:\n            return self.LESS_THAN_TXT\n        version_number = '.'.join(version[2:])\n        if version_number not in self.ALLOWED_VERSIONS:\n            if version_number in self.TOO_RECENT_VERSIONS:\n                return self.TOO_RECENT_VERSION_TXT\n            return self.OLD_VERSION_TXT\n        return None\n\n    def _check_pragma(self, version):\n        if version in self.BUGGY_VERSIONS:\n            return self.BUGGY_VERSION_TXT\n        versions = PATTERN.findall(version)\n        if len(versions) == 1:\n            version = versions[0]\n            return self._check_version(version)\n        elif len(versions) == 2:\n            version_left = versions[0]\n            version_right = versions[1]\n            # Only allow two elements if the second one is\n            # <0.5.0 or <0.6.0\n            if version_right not in [('<', '', '0', '5', '0'), ('<', '', '0', '6', '0')]:\n                return self.COMPLEX_PRAGMA_TXT\n            return self._check_version(version_left)\n        else:\n            return self.COMPLEX_PRAGMA_TXT\n    def _detect(self):\n        \"\"\"\n        Detects pragma statements that allow for outdated solc versions.\n        :return: Returns the relevant JSON data for the findings.\n        \"\"\"\n        # Detect all version related pragmas and check if they are disallowed.\n        results = []\n        pragma = self.slither.pragma_directives\n        disallowed_pragmas = []\n        detected_version = False\n        for p in pragma:\n            # Skip any pragma directives which do not refer to version\n            if len(p.directive) < 1 or p.directive[0] != \"solidity\":\n                continue\n\n            # This is version, so we test if this is disallowed.\n            detected_version = True\n            reason = self._check_pragma(p.version)\n            if reason:\n                disallowed_pragmas.append((reason, p))\n\n        # If we found any disallowed pragmas, we output our findings.\n        if disallowed_pragmas:\n            for (reason, p) in disallowed_pragmas:\n                info = f\"Pragma version \\\"{p.version}\\\" {reason} ({p.source_mapping_str})\\n\"\n\n                json = self.generate_json_result(info)\n                self.add_pragma_to_json(p, json)\n                results.append(json)\n\n        return results\n\n    @staticmethod\n    def _format(slither, result):\n        format(slither, result)\n", "path": "slither/detectors/attributes/incorrect_solc.py"}], "after_files": [{"content": "\"\"\"\n    Check if an incorrect version of solc is used\n\"\"\"\n\nimport re\nfrom slither.detectors.abstract_detector import AbstractDetector, DetectorClassification\nfrom slither.formatters.attributes.incorrect_solc import format\n\n# group:\n# 0: ^ > >= < <= (optional)\n# 1: ' ' (optional)\n# 2: version number\n# 3: version number\n# 4: version number\nPATTERN = re.compile('(\\^|>|>=|<|<=)?([ ]+)?(\\d+)\\.(\\d+)\\.(\\d+)')\n\nclass IncorrectSolc(AbstractDetector):\n    \"\"\"\n    Check if an old version of solc is used\n    \"\"\"\n\n    ARGUMENT = 'solc-version'\n    HELP = 'Incorrect Solidity version (< 0.4.24 or complex pragma)'\n    IMPACT = DetectorClassification.INFORMATIONAL\n    CONFIDENCE = DetectorClassification.HIGH\n\n    WIKI = 'https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-versions-of-solidity'\n\n    WIKI_TITLE = 'Incorrect versions of Solidity'\n    WIKI_DESCRIPTION = '''\nSolc frequently releases new compiler versions. Using an old version prevents access to new Solidity security checks.\nWe recommend avoiding complex pragma statement.'''\n    WIKI_RECOMMENDATION = '''\nUse Solidity 0.4.25 or 0.5.3. Consider using the latest version of Solidity for testing the compilation, and a trusted version for deploying.'''\n\n    COMPLEX_PRAGMA_TXT = \"is too complex\"\n    OLD_VERSION_TXT = \"allows old versions\"\n    LESS_THAN_TXT = \"uses lesser than\"\n\n    TOO_RECENT_VERSION_TXT = \"necessitates versions too recent to be trusted. Consider deploying with 0.5.3\"\n    BUGGY_VERSION_TXT = \"is known to contain severe issue (https://solidity.readthedocs.io/en/v0.5.8/bugs.html)\"\n\n    # Indicates the allowed versions.\n    ALLOWED_VERSIONS = [\"0.4.25\", \"0.4.26\", \"0.5.3\"]\n    # Indicates the versions too recent.\n    TOO_RECENT_VERSIONS = [\"0.5.4\", \"0.5.7\", \"0.5.8\", \"0.5.9\", \"0.5.10\", \"0.5.11\"]\n    # Indicates the versions that should not be used.\n    BUGGY_VERSIONS = [\"0.4.22\", \"0.5.5\", \"0.5.6\", \"^0.4.22\", \"^0.5.5\", \"^0.5.6\"]\n\n    def _check_version(self, version):\n        op = version[0]\n        if op and not op in ['>', '>=', '^']:\n            return self.LESS_THAN_TXT\n        version_number = '.'.join(version[2:])\n        if version_number not in self.ALLOWED_VERSIONS:\n            if version_number in self.TOO_RECENT_VERSIONS:\n                return self.TOO_RECENT_VERSION_TXT\n            return self.OLD_VERSION_TXT\n        return None\n\n    def _check_pragma(self, version):\n        if version in self.BUGGY_VERSIONS:\n            return self.BUGGY_VERSION_TXT\n        versions = PATTERN.findall(version)\n        if len(versions) == 1:\n            version = versions[0]\n            return self._check_version(version)\n        elif len(versions) == 2:\n            version_left = versions[0]\n            version_right = versions[1]\n            # Only allow two elements if the second one is\n            # <0.5.0 or <0.6.0\n            if version_right not in [('<', '', '0', '5', '0'), ('<', '', '0', '6', '0')]:\n                return self.COMPLEX_PRAGMA_TXT\n            return self._check_version(version_left)\n        else:\n            return self.COMPLEX_PRAGMA_TXT\n    def _detect(self):\n        \"\"\"\n        Detects pragma statements that allow for outdated solc versions.\n        :return: Returns the relevant JSON data for the findings.\n        \"\"\"\n        # Detect all version related pragmas and check if they are disallowed.\n        results = []\n        pragma = self.slither.pragma_directives\n        disallowed_pragmas = []\n        detected_version = False\n        for p in pragma:\n            # Skip any pragma directives which do not refer to version\n            if len(p.directive) < 1 or p.directive[0] != \"solidity\":\n                continue\n\n            # This is version, so we test if this is disallowed.\n            detected_version = True\n            reason = self._check_pragma(p.version)\n            if reason:\n                disallowed_pragmas.append((reason, p))\n\n        # If we found any disallowed pragmas, we output our findings.\n        if disallowed_pragmas:\n            for (reason, p) in disallowed_pragmas:\n                info = f\"Pragma version \\\"{p.version}\\\" {reason} ({p.source_mapping_str})\\n\"\n\n                json = self.generate_json_result(info)\n                self.add_pragma_to_json(p, json)\n                results.append(json)\n\n        return results\n\n    @staticmethod\n    def _format(slither, result):\n        format(slither, result)\n", "path": "slither/detectors/attributes/incorrect_solc.py"}]}