コード例 #1
0
ファイル: ReferenceCounts.php プロジェクト: kangkot/phan
 /**
  * Take a look at all globally accessible elements and see if
  * we can find any dead code that is never referenced
  *
  * @return void
  */
 public static function analyzeReferenceCounts(CodeBase $code_base)
 {
     // Check to see if dead code detection is enabled. Keep
     // in mind that the results here are just a guess and
     // we can't tell with certainty that anything is
     // definitely unreferenced.
     if (!Config::get()->dead_code_detection) {
         return;
     }
     // Get the count of all known elements
     $total_count = count($code_base->getMethodMap(), COUNT_RECURSIVE) + count($code_base->getPropertyMap(), COUNT_RECURSIVE) + count($code_base->getConstantMap(), COUNT_RECURSIVE) + count($code_base->getClassMap(), COUNT_RECURSIVE);
     $i = 0;
     $analyze_list = function ($list) use($code_base, &$i, $total_count) {
         foreach ($list as $name => $element) {
             CLI::progress('dead code', ++$i / $total_count);
             self::analyzeElementReferenceCounts($code_base, $element);
         }
     };
     $analyze_map = function ($map) use($code_base, &$i, $total_count) {
         foreach ($map as $fqsen_string => $list) {
             foreach ($list as $name => $element) {
                 CLI::progress('dead code', ++$i / $total_count);
                 // Don't worry about internal elements
                 if ($element->getContext()->isInternal()) {
                     continue;
                 }
                 $element_fqsen = $element->getFQSEN();
                 if ($element_fqsen instanceof FullyQualifiedClassElement) {
                     $class_fqsen = $element->getDefiningClassFQSEN();
                     // Don't analyze elements defined in a parent
                     // class
                     if ((string) $class_fqsen !== $fqsen_string) {
                         continue;
                     }
                     $defining_class = $element->getDefiningClass($code_base);
                     // Don't analyze elements on interfaces or on
                     // abstract classes, as they're uncallable.
                     if ($defining_class->isInterface() || $defining_class->isAbstract() || $defining_class->isTrait()) {
                         continue;
                     }
                     // Ignore magic methods
                     if ($element instanceof Method && $element->getIsMagic()) {
                         continue;
                     }
                 }
                 self::analyzeElementReferenceCounts($code_base, $element);
             }
         }
     };
     $analyze_map($code_base->getMethodMap());
     $analyze_map($code_base->getPropertyMap());
     $analyze_map($code_base->getConstantMap());
     $analyze_list($code_base->getClassMap());
 }
コード例 #2
0
ファイル: Analysis.php プロジェクト: Jvbzephir/phan
 /**
  * Take a pass over all functions verifying various
  * states.
  *
  * @return null
  */
 public static function analyzeFunctions(CodeBase $code_base)
 {
     $function_count = count($code_base->getMethodMap(), COUNT_RECURSIVE);
     $i = 0;
     foreach ($code_base->getMethodMap() as $fqsen_string => $method_map) {
         foreach ($method_map as $name => $method) {
             CLI::progress('method', ++$i / $function_count);
             if ($method->getContext()->isInternal()) {
                 continue;
             }
             DuplicateFunctionAnalyzer::analyzeDuplicateFunction($code_base, $method);
             ParameterTypesAnalyzer::analyzeParameterTypes($code_base, $method);
         }
     }
 }
コード例 #3
0
ファイル: Phan.php プロジェクト: nikkisnow/phan
 /**
  * Take a pass over all functions verifying various
  * states.
  *
  * @return null
  */
 private function analyzeFunctions(CodeBase $code_base)
 {
     $function_count = count($code_base->getMethodMap());
     $i = 0;
     foreach ($code_base->getMethodMap() as $fqsen_string => $method_map) {
         foreach ($method_map as $name => $method) {
             CLI::progress('method', ++$i / $function_count);
             if ($method->getContext()->isInternal()) {
                 continue;
             }
             self::analyzeDuplicateFunction($code_base, $method);
             self::analyzeParameterTypes($code_base, $method);
         }
     }
 }
コード例 #4
0
 /**
  * Take a look at all globally accessible elements and see if
  * we can find any dead code that is never referenced
  *
  * @return void
  */
 public static function analyzeReferenceCounts(CodeBase $code_base)
 {
     // Check to see if dead code detection is enabled. Keep
     // in mind that the results here are just a guess and
     // we can't tell with certainty that anything is
     // definitely unreferenced.
     if (!Config::get()->dead_code_detection) {
         return;
     }
     // Get the count of all known elements
     $total_count = count($code_base->getMethodMap(), COUNT_RECURSIVE) + count($code_base->getPropertyMap(), COUNT_RECURSIVE) + count($code_base->getConstantMap(), COUNT_RECURSIVE) + count($code_base->getClassMap(), COUNT_RECURSIVE);
     $i = 0;
     $analyze_list = function ($list, string $issue_type) use($code_base, &$i, $total_count) {
         foreach ($list as $name => $element) {
             CLI::progress('dead code', ++$i / $total_count);
             self::analyzeElementReferenceCounts($code_base, $element, $issue_type);
         }
     };
     $analyze_map = function ($map, string $issue_type) use($code_base, &$i, $total_count) {
         foreach ($map as $fqsen_string => $list) {
             foreach ($list as $name => $element) {
                 CLI::progress('dead code', ++$i / $total_count);
                 // Don't worry about internal elements
                 if ($element->isInternal()) {
                     continue;
                 }
                 $element_fqsen = $element->getFQSEN();
                 if (0 !== strpos((string) $element_fqsen, $fqsen_string)) {
                     continue;
                 }
                 // Skip methods that are overrides of other methods
                 if ($element_fqsen instanceof FullyQualifiedMethodName) {
                     if ($element->getIsOverride()) {
                         continue;
                     }
                 }
                 // Skip properties on classes that have a magic
                 // __get or __set method given that we can't track
                 // their access
                 if ($element instanceof Property) {
                     $defining_class = $element->getDefiningClass($code_base);
                     if ($defining_class->hasMethodWithName($code_base, '__set') || $defining_class->hasMethodWithName($code_base, '__get')) {
                         continue;
                     }
                 }
                 if ($element_fqsen instanceof FullyQualifiedClassElement) {
                     $class_fqsen = $element->getDefiningClassFQSEN();
                     // Don't analyze elements defined in a parent
                     // class
                     if ((string) $class_fqsen !== $fqsen_string) {
                         continue;
                     }
                     $defining_class = $element->getDefiningClass($code_base);
                     // Don't analyze elements on interfaces or on
                     // abstract classes, as they're uncallable.
                     if ($defining_class->isInterface() || $defining_class->isAbstract() || $defining_class->isTrait()) {
                         continue;
                     }
                     // Ignore magic methods
                     if ($element instanceof Method) {
                         // Doubly nested so that `$element` shows
                         // up as Method in Phan.
                         if ($element->getIsMagic()) {
                             continue;
                         }
                     }
                 }
                 self::analyzeElementReferenceCounts($code_base, $element, $issue_type);
             }
         }
     };
     $analyze_map($code_base->getMethodMap(), Issue::UnreferencedMethod);
     $analyze_map($code_base->getPropertyMap(), Issue::UnreferencedProperty);
     $analyze_map($code_base->getConstantMap(), Issue::UnreferencedConstant);
     $analyze_list($code_base->getClassMap(), Issue::UnreferencedClass);
 }