diff --git a/README.rst b/README.rst
index 8529e17bb69..9ee6854857a 100644
--- a/README.rst
+++ b/README.rst
@@ -1170,6 +1170,10 @@ Choose from the list of available rules:
 
   A final class must not have final methods.
 
+* **no_unneeded_import_alias** [@PhpCsFixer]
+
+  Remove unneeded alias in ``use`` clauses.
+
 * **no_unreachable_default_argument_value** [@PhpCsFixer:risky]
 
   In function arguments there must not be arguments with default values
diff --git a/src/Fixer/Import/NoUnneededImportAliasFixer.php b/src/Fixer/Import/NoUnneededImportAliasFixer.php
new file mode 100644
index 00000000000..5815c3e261c
--- /dev/null
+++ b/src/Fixer/Import/NoUnneededImportAliasFixer.php
@@ -0,0 +1,100 @@
+<?php
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Fixer\Import;
+
+use PhpCsFixer\AbstractFixer;
+use PhpCsFixer\FixerDefinition\CodeSample;
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\Tokenizer\Analyzer\Analysis\NamespaceUseAnalysis;
+use PhpCsFixer\Tokenizer\Analyzer\NamespaceUsesAnalyzer;
+use PhpCsFixer\Tokenizer\Tokens;
+
+final class NoUnneededImportAliasFixer extends AbstractFixer
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getDefinition()
+    {
+        return new FixerDefinition(
+            'Remove unneeded alias in `use` clauses.',
+            [
+                new CodeSample(
+                    '<?php
+namespace Foo;
+
+use Bar\Baz as Baz;
+
+use const some\a\ConstA as ConstA;
+use function some\a\fn_b as fn_b;
+'
+                ),
+            ]
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getPriority()
+    {
+        // should be run after the NoUnusedImportsFixer (just for save performance)
+        return -15;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isCandidate(Tokens $tokens)
+    {
+        return $tokens->isAllTokenKindsFound([T_USE, T_AS]);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function applyFix(\SplFileInfo $file, Tokens $tokens)
+    {
+        $useDeclarations = (new NamespaceUsesAnalyzer())->getDeclarationsFromTokens($tokens, false);
+
+        foreach ($useDeclarations as $declaration) {
+            if (!$declaration->isAliased()) {
+                continue;
+            }
+            $shortNameStartPos = strrpos($declaration->getFullName(), '\\');
+            $shortName = false === $shortNameStartPos ? $declaration->getFullName() : substr($declaration->getFullName(), $shortNameStartPos + 1);
+
+            if ($declaration->getShortName() !== $shortName) {
+                continue;
+            }
+
+            $this->removeAlias($tokens, $declaration);
+        }
+    }
+
+    private function removeAlias(Tokens $tokens, NamespaceUseAnalysis $declaration)
+    {
+        $asIndex = $tokens->getNextTokenOfKind($declaration->getStartIndex(), [[T_AS]]);
+        if (null === $asIndex || $asIndex > $declaration->getEndIndex()) {
+            return;
+        }
+
+        for ($i = $tokens->getPrevMeaningfulToken($asIndex) + 1; $i <= $declaration->getEndIndex() - 1; ++$i) {
+            if ($tokens[$i]->isWhitespace() && !($tokens[$i - 1]->isComment() || $tokens[$i + 1]->isComment() || $tokens[$i + 1]->isGivenKind([T_CLOSE_TAG]))) {
+                $tokens->clearAt($i);
+            } elseif ($tokens[$i]->isGivenKind([T_AS, T_STRING])) {
+                $tokens->clearAt($i);
+            }
+        }
+    }
+}
diff --git a/src/RuleSet.php b/src/RuleSet.php
index 580cc75a45d..74b2cd281bb 100644
--- a/src/RuleSet.php
+++ b/src/RuleSet.php
@@ -238,6 +238,7 @@ final class RuleSet implements RuleSetInterface
             'no_superfluous_elseif' => true,
             'no_unneeded_curly_braces' => true,
             'no_unneeded_final_method' => true,
+            'no_unneeded_import_alias' => true,
             'no_unset_cast' => true,
             'no_useless_else' => true,
             'no_useless_return' => true,
diff --git a/src/Tokenizer/Analyzer/NamespaceUsesAnalyzer.php b/src/Tokenizer/Analyzer/NamespaceUsesAnalyzer.php
index 7b3f4412bfa..960f4a54aaa 100644
--- a/src/Tokenizer/Analyzer/NamespaceUsesAnalyzer.php
+++ b/src/Tokenizer/Analyzer/NamespaceUsesAnalyzer.php
@@ -24,32 +24,34 @@ final class NamespaceUsesAnalyzer
 {
     /**
      * @param Tokens $tokens
+     * @param bool   $skipMultipleUseStatement
      *
      * @return NamespaceUseAnalysis[]
      */
-    public function getDeclarationsFromTokens(Tokens $tokens)
+    public function getDeclarationsFromTokens(Tokens $tokens, $skipMultipleUseStatement = true)
     {
         $tokenAnalyzer = new TokensAnalyzer($tokens);
         $useIndexes = $tokenAnalyzer->getImportUseIndexes();
 
-        return $this->getDeclarations($tokens, $useIndexes);
+        return $this->getDeclarations($tokens, $useIndexes, $skipMultipleUseStatement);
     }
 
     /**
      * @param Tokens $tokens
      * @param array  $useIndexes
+     * @param bool   $skipMultipleUseStatement
      *
      * @return NamespaceUseAnalysis[]
      */
-    private function getDeclarations(Tokens $tokens, array $useIndexes)
+    private function getDeclarations(Tokens $tokens, array $useIndexes, $skipMultipleUseStatement = true)
     {
         $uses = [];
 
         foreach ($useIndexes as $index) {
             $endIndex = $tokens->getNextTokenOfKind($index, [';', [T_CLOSE_TAG]]);
-            $analysis = $this->parseDeclaration($tokens, $index, $endIndex);
-            if ($analysis) {
-                $uses[] = $analysis;
+            $analyses = $this->parseDeclaration($tokens, $index, $endIndex, $skipMultipleUseStatement);
+            if ($analyses) {
+                $uses = array_merge($uses, $analyses);
             }
         }
 
@@ -60,20 +62,36 @@ private function getDeclarations(Tokens $tokens, array $useIndexes)
      * @param Tokens $tokens
      * @param int    $startIndex
      * @param int    $endIndex
+     * @param bool   $skipMultipleUseStatement
      *
-     * @return null|NamespaceUseAnalysis
+     * @return null|NamespaceUseAnalysis[]
      */
-    private function parseDeclaration(Tokens $tokens, $startIndex, $endIndex)
+    private function parseDeclaration(Tokens $tokens, $startIndex, $endIndex, $skipMultipleUseStatement = true)
     {
+        $namespaceUseAnalyses = [];
         $fullName = $shortName = '';
         $aliased = false;
 
         $type = NamespaceUseAnalysis::TYPE_CLASS;
         for ($i = $startIndex; $i <= $endIndex; ++$i) {
             $token = $tokens[$i];
-            if ($token->equals(',') || $token->isGivenKind(CT::T_GROUP_IMPORT_BRACE_CLOSE)) {
+            if ($token->equals(',')) {
+                if ($skipMultipleUseStatement) {
+                    return null;
+                }
+                $namespaceUseAnalyses[] = new NamespaceUseAnalysis(
+                    trim($fullName),
+                    $shortName,
+                    $aliased,
+                    $startIndex,
+                    $i,
+                    $type
+                );
+                $fullName = $shortName = '';
+                $aliased = false;
+                $startIndex = $i + 1;
+            } elseif ($token->isGivenKind(CT::T_GROUP_IMPORT_BRACE_CLOSE)) {
                 // do not touch group use declarations until the logic of this is added (for example: `use some\a\{ClassD};`)
-                // ignore multiple use statements that should be split into few separate statements (for example: `use BarB, BarC as C;`)
                 return null;
             }
 
@@ -99,7 +117,7 @@ private function parseDeclaration(Tokens $tokens, $startIndex, $endIndex)
             }
         }
 
-        return new NamespaceUseAnalysis(
+        $namespaceUseAnalyses[] = new NamespaceUseAnalysis(
             trim($fullName),
             $shortName,
             $aliased,
@@ -107,5 +125,7 @@ private function parseDeclaration(Tokens $tokens, $startIndex, $endIndex)
             $endIndex,
             $type
         );
+
+        return $namespaceUseAnalyses;
     }
 }
diff --git a/tests/Fixer/Import/NoUnneededImportAliasFixerTest.php b/tests/Fixer/Import/NoUnneededImportAliasFixerTest.php
new file mode 100644
index 00000000000..88e185b3ef1
--- /dev/null
+++ b/tests/Fixer/Import/NoUnneededImportAliasFixerTest.php
@@ -0,0 +1,201 @@
+<?php
+
+/*
+ * This file is part of PHP CS Fixer.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace PhpCsFixer\Tests\Fixer\Import;
+
+use PhpCsFixer\Tests\Test\AbstractFixerTestCase;
+
+/**
+ * @internal
+ *
+ * @covers \PhpCsFixer\Fixer\Import\NoUnneededImportAliasFixer
+ */
+final class NoUnneededImportAliasFixerTest extends AbstractFixerTestCase
+{
+    /**
+     * @param string      $expected
+     * @param null|string $input
+     *
+     * @dataProvider provideFixCases
+     */
+    public function testFix($expected, $input = null)
+    {
+        $this->doTest($expected, $input);
+    }
+
+    public function provideFixCases()
+    {
+        return [
+            'simple' => [
+                <<<'EOF'
+<?php
+
+use Foo\Bar\FooBar;
+use Foo\Bar\Baz as Alias;
+use const some\a\ConstA;
+use function some\a\fn_b;
+EOF
+                ,
+                <<<'EOF'
+<?php
+
+use Foo\Bar\FooBar as FooBar;
+use Foo\Bar\Baz as Alias;
+use const some\a\ConstA as ConstA;
+use function some\a\fn_b as fn_b;
+EOF
+            ],
+            'multiple use' => [
+                <<<'EOF'
+<?php
+
+use Foo\Bar\FooBar, Foo\Bar\Baz as Alias;
+use const some\a\ConstB as Alias, some\a\ConstA;
+use function some\a\fn_b, some\a\fn_c;
+EOF
+                ,
+                <<<'EOF'
+<?php
+
+use Foo\Bar\FooBar as FooBar, Foo\Bar\Baz as Alias;
+use const some\a\ConstB as Alias, some\a\ConstA as ConstA;
+use function some\a\fn_b as fn_b, some\a\fn_c as fn_c;
+EOF
+            ],
+            'comments' => [
+                <<<'EOF'
+<?php
+
+use Foo\Bar\BazEnd/**/;
+use Foo\Bar\BazEndWithSpace  /**/ ;
+use Foo\Bar\BazAfterAs/**/;
+use Foo\Bar\BazAfterAsWithSpace  /**/ ;
+use Foo\Bar\BazBeforeAs/**/;
+use Foo\Bar\BazBeforeAsWithSpace  /**/  ;
+use/**/Foo\Bar\BazAfterUse;
+use  /**/  Foo\Bar\BazAfterUseWithSpace;
+use Foo\Bar\Multiple  /**/ /**/,/**/Foo\Bar\Second;
+use Foo\Bar\BazAfterTricky  // comment
+  ;
+use const some\a\ConstA/**/;
+use function some\a\fn_b /**/ ;
+EOF
+                ,
+                <<<'EOF'
+<?php
+
+use Foo\Bar\BazEnd as BazEnd/**/;
+use Foo\Bar\BazEndWithSpace as BazEndWithSpace  /**/ ;
+use Foo\Bar\BazAfterAs as/**/BazAfterAs;
+use Foo\Bar\BazAfterAsWithSpace as  /**/ BazAfterAsWithSpace;
+use Foo\Bar\BazBeforeAs/**/as BazBeforeAs;
+use Foo\Bar\BazBeforeAsWithSpace  /**/  as BazBeforeAsWithSpace;
+use/**/Foo\Bar\BazAfterUse as BazAfterUse;
+use  /**/  Foo\Bar\BazAfterUseWithSpace as BazAfterUseWithSpace;
+use Foo\Bar\Multiple as  /**/ Multiple/**/,/**/Foo\Bar\Second as Second;
+use Foo\Bar\BazAfterTricky as  // comment
+  BazAfterTricky ;
+use const some\a\ConstA as ConstA/**/;
+use function some\a\fn_b /**/ as fn_b;
+EOF
+            ],
+            'case sensitive' => [
+                <<<'EOF'
+<?php
+
+use Foo\Bar\FooBar as fooBar;
+use const some\a\ConstA as Consta;
+use function some\a\fn_b as fn_B;
+EOF
+            ],
+            'extra spaces' => [
+                <<<'EOF'
+<?php
+
+use Foo\Bar\FooBar;
+use const some\a\ConstA;
+use function some\a\fn_b;
+EOF
+                ,
+                <<<'EOF'
+<?php
+
+use Foo\Bar\FooBar  as FooBar  ;
+use const some\a\ConstA as   ConstA   ;
+use function some\a\fn_b   as   fn_b ;
+EOF
+            ],
+            'root import' => [
+                <<<'EOF'
+<?php
+
+use FooBarFooBar;
+use const someConstA;
+use function someFunction;
+EOF
+                ,
+                <<<'EOF'
+<?php
+
+use FooBarFooBar as FooBarFooBar;
+use const someConstA as someConstA;
+use function someFunction as someFunction;
+EOF
+            ],
+            'leading slash' => [
+                <<<'EOF'
+<?php
+
+use \Foo\Bar\FooBar;
+use const \some\a\ConstA;
+use function \some\a\fn_b;
+EOF
+                ,
+                <<<'EOF'
+<?php
+
+use \Foo\Bar\FooBar as FooBar;
+use const \some\a\ConstA as ConstA;
+use function \some\a\fn_b as fn_b;
+EOF
+            ],
+            'close_tag_1' => [
+                '<?php
+     use B\C?>inline content<?php use A\D; use E\F?>',
+                '<?php
+     use B\C as C?>inline content<?php use A\D; use E\F as F?>',
+            ],
+            'close_tag_2' => [
+                '<?php
+     use B\C ?>inline content<?php use A\D; use E\F ?>',
+                '<?php
+     use B\C as C ?>inline content<?php use A\D; use E\F as F ?>',
+            ],
+            'close_tag_3' => [
+                '<?php use A\B;?>',
+                '<?php use A\B as B;?>',
+            ],
+            'close_tag_4' => [
+                '<?php use A\B?>',
+                '<?php use A\B as B?>',
+            ],
+            'close_tag_5' => [
+                '<?php use A\B; ?>',
+                '<?php use A\B as B; ?>',
+            ],
+            'close_tag_6' => [
+                '<?php use A\B ?>',
+                '<?php use A\B as B ?>',
+            ],
+        ];
+    }
+}
diff --git a/tests/Tokenizer/Analyzer/NamespaceUsesAnalyzerTest.php b/tests/Tokenizer/Analyzer/NamespaceUsesAnalyzerTest.php
index 31717564c88..95d91ff6e8f 100644
--- a/tests/Tokenizer/Analyzer/NamespaceUsesAnalyzerTest.php
+++ b/tests/Tokenizer/Analyzer/NamespaceUsesAnalyzerTest.php
@@ -29,21 +29,22 @@ final class NamespaceUsesAnalyzerTest extends TestCase
     /**
      * @param string $code
      * @param array  $expected
+     * @param bool   $skipMultipleUseStatement
      *
      * @dataProvider provideNamespaceUsesCases
      */
-    public function testUsesFromTokens($code, $expected)
+    public function testUsesFromTokens($code, $expected, $skipMultipleUseStatement = true)
     {
         $tokens = Tokens::fromCode($code);
         $analyzer = new NamespaceUsesAnalyzer();
 
-        static::assertSame(serialize($expected), serialize($analyzer->getDeclarationsFromTokens($tokens)));
+        static::assertSame(serialize($expected), serialize($analyzer->getDeclarationsFromTokens($tokens, $skipMultipleUseStatement)));
     }
 
     public function provideNamespaceUsesCases()
     {
         return [
-            ['<?php // no uses', [], []],
+            ['<?php // no uses', [], true],
             ['<?php use Foo\Bar;', [
                 new NamespaceUseAnalysis(
                     'Foo\Bar',
@@ -53,7 +54,7 @@ public function provideNamespaceUsesCases()
                     6,
                     NamespaceUseAnalysis::TYPE_CLASS
                 ),
-            ], [1]],
+            ], true],
             ['<?php use Foo\Bar; use Foo\Baz;', [
                 new NamespaceUseAnalysis(
                     'Foo\Bar',
@@ -71,7 +72,7 @@ public function provideNamespaceUsesCases()
                     13,
                     NamespaceUseAnalysis::TYPE_CLASS
                 ),
-            ], [1, 8]],
+            ], true],
             ['<?php use \Foo\Bar;', [
                 new NamespaceUseAnalysis(
                     '\Foo\Bar',
@@ -81,7 +82,7 @@ public function provideNamespaceUsesCases()
                     7,
                     NamespaceUseAnalysis::TYPE_CLASS
                 ),
-            ], [1]],
+            ], true],
             ['<?php use Foo\Bar as Baz;', [
                 new NamespaceUseAnalysis(
                     'Foo\Bar',
@@ -91,7 +92,7 @@ public function provideNamespaceUsesCases()
                     10,
                     NamespaceUseAnalysis::TYPE_CLASS
                 ),
-            ], [1]],
+            ], true],
             ['<?php use Foo\Bar as Baz; use Foo\Buz as Baz;', [
                 new NamespaceUseAnalysis(
                     'Foo\Bar',
@@ -109,7 +110,7 @@ public function provideNamespaceUsesCases()
                     21,
                     NamespaceUseAnalysis::TYPE_CLASS
                 ),
-            ], [1, 12]],
+            ], true],
             ['<?php use function My\count;', [
                 new NamespaceUseAnalysis(
                     'My\count',
@@ -119,7 +120,7 @@ public function provideNamespaceUsesCases()
                     8,
                     NamespaceUseAnalysis::TYPE_FUNCTION
                 ),
-            ], [1]],
+            ], true],
             ['<?php use function My\count as myCount;', [
                 new NamespaceUseAnalysis(
                     'My\count',
@@ -129,7 +130,7 @@ public function provideNamespaceUsesCases()
                     12,
                     NamespaceUseAnalysis::TYPE_FUNCTION
                 ),
-            ], [1]],
+            ], true],
             ['<?php use const My\Full\CONSTANT;', [
                 new NamespaceUseAnalysis(
                     'My\Full\CONSTANT',
@@ -139,12 +140,91 @@ public function provideNamespaceUsesCases()
                     10,
                     NamespaceUseAnalysis::TYPE_CONSTANT
                 ),
-            ], [1]],
+            ], true],
 
-            // TODO: How to support these:
+            ['<?php use Foo\Bar, Foo\Baz;', [], true],
+            ['<?php use Foo\Bar, Foo\Baz;', [
+                new NamespaceUseAnalysis(
+                    'Foo\Bar',
+                    'Bar',
+                    false,
+                    1,
+                    6,
+                    NamespaceUseAnalysis::TYPE_CLASS
+                ),
+                new NamespaceUseAnalysis(
+                    'Foo\Baz',
+                    'Baz',
+                    false,
+                    7,
+                    11,
+                    NamespaceUseAnalysis::TYPE_CLASS
+                ),
+            ], false],
+            ['<?php use Foo\Bar as Baz, Some\ClassA as Alias,No\Space;', [
+                new NamespaceUseAnalysis(
+                    'Foo\Bar',
+                    'Baz',
+                    true,
+                    1,
+                    10,
+                    NamespaceUseAnalysis::TYPE_CLASS
+                ),
+                new NamespaceUseAnalysis(
+                    'Some\ClassA',
+                    'Alias',
+                    true,
+                    11,
+                    19,
+                    NamespaceUseAnalysis::TYPE_CLASS
+                ),
+                new NamespaceUseAnalysis(
+                    'No\Space',
+                    'Space',
+                    false,
+                    20,
+                    23,
+                    NamespaceUseAnalysis::TYPE_CLASS
+                ),
+            ], false],
+            ['<?php use function some\a\fn_a as alias, some\a\fn_b as b;', [
+                new NamespaceUseAnalysis(
+                    'some\a\fn_a',
+                    'alias',
+                    true,
+                    1,
+                    14,
+                    NamespaceUseAnalysis::TYPE_FUNCTION
+                ),
+                new NamespaceUseAnalysis(
+                    'some\a\fn_b',
+                    'b',
+                    true,
+                    15,
+                    25,
+                    NamespaceUseAnalysis::TYPE_FUNCTION
+                ),
+            ], false],
+            ['<?php use const some\a\ConstA as A, ConstB;', [
+                new NamespaceUseAnalysis(
+                    'some\a\ConstA',
+                    'A',
+                    true,
+                    1,
+                    14,
+                    NamespaceUseAnalysis::TYPE_CONSTANT
+                ),
+                new NamespaceUseAnalysis(
+                    'ConstB',
+                    'ConstB',
+                    false,
+                    15,
+                    17,
+                    NamespaceUseAnalysis::TYPE_CONSTANT
+                ),
+            ], false],
 
-            // Multiple imports on one line:
-            // use My\Full\Classname as Another, My\Full\NSname;
+            // TODO: How to support these:
 
             // PHP 7+ code
             // use some\namespace\{ClassA, ClassB, ClassC as C};