text:
<?php

namespace Sabre\CardDAV;

use Sabre\DAV;

class AddressBookQueryParser {

    const TEST_ANYOF = 'anyof';
    const TEST_ALLOF = 'allof';

    /**
     * List of requested properties the client wanted
     *
     * @var array
     */
    public $requestedProperties;

    /**
     * The number of results the client wants
     *
     * null means it wasn't specified, which in most cases means 'all results'.
     *
     * @var int|null
     */
    public $limit;

    /**
     * List of property filters.
     *
     * @var array
     */
    public $filters;

    /**
     * Either TEST_ANYOF or TEST_ALLOF
     *
     * @var string
     */
    public $test;

    /**
     * DOM Document
     *
     * @var DOMDocument
     */
    protected $dom;

    /**
     * DOM XPath object
     *
     * @var DOMXPath
     */
    protected $xpath;

    /**
     * Creates the parser
     *
     * @param \DOMDocument $dom
     */
    public function __construct(\DOMDocument $dom) {

        $this->dom = $dom;

        $this->xpath = new \DOMXPath($dom);
        $this->xpath->registerNameSpace('card',Plugin::NS_CARDDAV);

    }

    /**
     * Parses the request.
     *
     * @return void
     */
    public function parse() {

        $filterNode = null;

        $limit = $this->xpath->evaluate('number(/card:addressbook-query/card:limit/card:nresults)');
        if (is_nan($limit)) $limit = null;

        $filter = $this->xpath->query('/card:addressbook-query/card:filter');

        // According to the CardDAV spec there needs to be exactly 1 filter
        // element. However, KDE 4.8.2 contains a bug that will encode 0 filter
        // elements, so this is a workaround for that.
        //
        // See: https://bugs.kde.org/show_bug.cgi?id=300047
        if ($filter->length === 0) {
            $test = null;
            $filter = null;
        } elseif ($filter->length === 1) {
            $filter = $filter->item(0);
            $test = $this->xpath->evaluate('string(@test)', $filter);
        } else {
            throw new DAV\Exception\BadRequest('Only one filter element is allowed');
        }

        if (!$test) $test = self::TEST_ANYOF;
        if ($test !== self::TEST_ANYOF && $test !== self::TEST_ALLOF) {
            throw new DAV\Exception\BadRequest('The test attribute must either hold "anyof" or "allof"');
        }

        $propFilters = array();

        $propFilterNodes = $this->xpath->query('card:prop-filter', $filter);
        for($ii=0; $ii < $propFilterNodes->length; $ii++) {

            $propFilters[] = $this->parsePropFilterNode($propFilterNodes->item($ii));

        }

        $this->filters = $propFilters;
        $this->limit = $limit;
        $this->requestedProperties = array_keys(DAV\XMLUtil::parseProperties($this->dom->firstChild));
        $this->test = $test;

    }

    /**
     * Parses the prop-filter xml element
     *
     * @param \DOMElement $propFilterNode
     * @return array
     */
    protected function parsePropFilterNode(\DOMElement $propFilterNode) {

        $propFilter = array();
        $propFilter['name'] = $propFilterNode->getAttribute('name');
        $propFilter['test'] = $propFilterNode->getAttribute('test');
        if (!$propFilter['test']) $propFilter['test'] = 'anyof';

        $propFilter['is-not-defined'] = $this->xpath->query('card:is-not-defined', $propFilterNode)->length>0;

        $paramFilterNodes = $this->xpath->query('card:param-filter', $propFilterNode);

        $propFilter['param-filters'] = array();

        for($ii=0;$ii<$paramFilterNodes->length;$ii++) {

            $propFilter['param-filters'][] = $this->parseParamFilterNode($paramFilterNodes->item($ii));

        }
        $propFilter['text-matches'] = array();
        $textMatchNodes = $this->xpath->query('card:text-match', $propFilterNode);

        for($ii=0;$ii<$textMatchNodes->length;$ii++) {

            $propFilter['text-matches'][] = $this->parseTextMatchNode($textMatchNodes->item($ii));

        }

        return $propFilter;

    }

    /**
     * Parses the param-filter element
     *
     * @param \DOMElement $paramFilterNode
     * @return array
     */
    public function parseParamFilterNode(\DOMElement $paramFilterNode) {

        $paramFilter = array();
        $paramFilter['name'] = $paramFilterNode->getAttribute('name');
        $paramFilter['is-not-defined'] = $this->xpath->query('card:is-not-defined', $paramFilterNode)->length>0;
        $paramFilter['text-match'] = null;

        $textMatch = $this->xpath->query('card:text-match', $paramFilterNode);
        if ($textMatch->length>0) {
            $paramFilter['text-match'] = $this->parseTextMatchNode($textMatch->item(0));
        }

        return $paramFilter;

    }

    /**
     * Text match
     *
     * @param \DOMElement $textMatchNode
     * @return array
     */
    public function parseTextMatchNode(\DOMElement $textMatchNode) {

        $matchType = $textMatchNode->getAttribute('match-type');
        if (!$matchType) $matchType = 'contains';

        if (!in_array($matchType, array('contains', 'equals', 'starts-with', 'ends-with'))) {
            throw new DAV\Exception\BadRequest('Unknown match-type: ' . $matchType);
        }

        $negateCondition = $textMatchNode->getAttribute('negate-condition');
        $negateCondition = $negateCondition==='yes';
        $collation = $textMatchNode->getAttribute('collation');
        if (!$collation) $collation = 'i;unicode-casemap';

        return array(
            'negate-condition' => $negateCondition,
            'collation' => $collation,
            'match-type' => $matchType,
            'value' => $textMatchNode->nodeValue
        );

    }

}


text:
FactoryBot.define do
  factory :historical_emissions_data_source,
          class: 'HistoricalEmissions::DataSource' do
    name { 'MyText' }
    display_name { 'MyText' }
    metadata_dataset { 'historical_emissions_MyText' }
  end
end

redpajama_set_name: RedPajamaGithub


text:
(function () {
  'use strict';

  var timeUnitsFactory, timeParserFactory, timeDirective,

    RESET_KEY_DELAY_MS = 2000,

    KEYS = {
      LEFT: 37,
      UP: 38,
      RIGHT: 39,
      DOWN: 40,
      TAB: 9
    };

  timeUnitsFactory = [function () {
    return {
      '24hour': {
        increment: function (date) {
          var hours = date.getHours();

          // we don't want to change the day
          if (hours === 23) {
            hours -= 24;
          }

          date.setHours(hours + 1);
        },
        decrement: function (date) {
          var hours = date.getHours();

          // we don't want to change the day
          if (hours === 0 ) {
            hours += 24;
          }

          date.setHours(hours - 1);
        },
        set: function (date, hours) {
          var result = true;

          if (hours < 0 || hours > 23) {
            hours = 0;
            result = false;
          }

          date.setHours(hours);

          return result;
        }
      },

      '12hour': {
        increment: function (date) {
          var hours = date.getHours();

          // we don't want to change the am/pm
          if (hours === 11 || hours === 23) {
            hours -= 12;
          }

          date.setHours(hours + 1);
        },
        decrement: function (date) {
          var hours = date.getHours();

          // we don't want to change the am/pm
          if (hours === 0 || hours === 12) {
            hours += 12;
          }

          date.setHours(hours - 1);
        },
        set: function (date, hours) {
          var result = true;

          if (hours < 1 || hours > 11) {
            hours = 0;
            result = false;
          }

          date.setHours(hours);

          return result;
        }
      },

      minute: {
        increment: function (date) {
          var minutes = date.getMinutes();

          // we don't want to change the hour
          if (minutes === 59) {
            minutes -= 60;
          }

          this.set(date, minutes + 1);
        },
        decrement: function (date) {
          var minutes = date.getMinutes();

          // we don't want to change the hour
          if (minutes === 0) {
            minutes += 60;
          }

          this.set(date, minutes - 1);
        },
        set: function (date, minutes) {
          var result = true;

          if (minutes < 0 || minutes >= 60) {
            minutes = 0;
            result = false;
          }

          date.setMinutes(minutes);

          return result;
        }
      },

      ampm: {
        toggle: function (date) {
          var hour = date.getHours();
          if (hour > 12) {
            date.setHours(hour - 12);
          } else {
            date.setHours(hour + 12);
          }
        },
        increment: function (date) { this.toggle(date); },
        decrement: function (date) { this.toggle(date); }
      }
    };
  }];

  timeParserFactory = ['dzInputTimeUnits', 'dateFilter', function (timeUnits, dateFilter) {
    var GRAMMAR = {
      'hh' : { pattern: /0[0-9]|1[0-2]/          , unit: timeUnits['12hour'] },
      'h'  : { pattern: /0[0-9]|1[0-2]|[1-9]/    , unit: timeUnits['12hour'] },
      'HH' : { pattern: /[0-1][0-9]|2[0-3]/      , unit: timeUnits['24hour'] },
      'H'  : { pattern: /[0-1][0-9]|2[0-3]|[0-9]/, unit: timeUnits['24hour'] },
      'mm' : { pattern: /[0-5][0-9]/             , unit: timeUnits.minute },
      'm'  : { pattern: /[0-5][0-9]|[0-9]/       , unit: timeUnits.minute },
      'ss' : { pattern: /[0-5][0-9]/             , unit: timeUnits.second },
      's'  : { pattern: /[0-5][0-9]|[0-9]/       , unit: timeUnits.second },
      'a'  : { pattern: /AM|PM/                  , unit: timeUnits.ampm   },
    };

    // modified from http://stackoverflow.com/a/2188651
    return {
      parse: function (timeString) {
        var match, hours, minutes, isPm, date;

        if (!timeString) { return null; }

        match = timeString.match(/(\d\d?)(:?(\d\d))?\s*(p?)/i);
        if (match == null) { return null; }

        isPm = match[4];
        hours = parseInt(match[1], 10);
        minutes = parseInt(match[3], 10) || 0;

        if (hours == 12 && !isPm) {
          hours = 0;
        }
        else {
          hours += (hours < 12 && isPm)? 12 : 0;
        }

        date = new Date(1970, 0, 1);
        date.setHours(hours);
        date.setMinutes(minutes);
        date.setSeconds(0, 0);
        return date;
      },

      /**
       * Finds the start and end index of the time string
       * unit containing the given position.
       * Used for selecting the relevant time unit in
       * a text input (hour, minute, am/pm).
       */
      getUnitContainingCursor: function (pos, format, value) {
        var formatMatch, token, output, nextStart,
          selection = { start: 0, end: 0 },
          regex = new RegExp(Object.keys(GRAMMAR).join('|'), 'i');

        // search for each date element in the format string.
        // handles the case where pos is at the end of the string
        while ((formatMatch = regex.exec(format))) {
          token = GRAMMAR[formatMatch[0]];
          output = dateFilter(value, formatMatch[0]);
          nextStart = selection.end + formatMatch.index;

          // handle the case where pos is in between two units
          if (pos < nextStart) {
            break;
          }

          // move the selection to this block
          selection.start = nextStart;
          selection.end   = selection.start + output.length;
          selection.unit  = token.unit;

          // handles the case where pos is within the time element
          if (pos >= selection.start &&
              pos <  selection.end) {
            break;
          }

          // remove the first portion of the string
          format = format.substr(formatMatch.index + formatMatch[0].length);
        }

        return selection;
      }
    };
  }];

  timeDirective = ['dateFilter', 'dzInputTimeParser', '$timeout', function (dateFilter, timeParser, $timeout) {
    return {
      scope: {
        time: '=ngModel'
      },
      controller: ['$scope', '$element', '$attrs', function ($scope, $element, $attrs) {
        var selection, lastCh, resetKeyTimeoutPromise,
          ctrl = this;

        ctrl.options = {
          format: $attrs.format || 'hh:mm a'
        };

        ctrl.refocus = function () {
          $timeout(function () {
            ctrl.$$resetSelection($element[0].selectionStart);
          }, 0, false);
        };

        ctrl.$$resetSelection = function (cursorPosition) {
          selection = timeParser.getUnitContainingCursor(
            cursorPosition,
            ctrl.options.format,
            $scope.time);

          ctrl.$$setSelection(selection.start, selection.end);
        };

        ctrl.$$setSelection = function (start, end) {
          $element[0].selectionStart = start;
          $element[0].selectionEnd = end;
        };

        ctrl.moveRight = function () {
          var
            count = 0,
            currentUnit = selection.unit;
          do {
            ctrl.$$resetSelection(selection.end + count);
            count++;
          } while (selection.end + count <= $element.val().length
            && selection.unit === currentUnit);
        };

        ctrl.moveLeft = function () {
          var
            count = 0,
            currentUnit = selection.unit;
          do {
            ctrl.$$resetSelection(selection.start - count);
            count++;
          } while (selection.start - count >= 0
            && selection.unit === currentUnit);
        };

        ctrl.$$resetLastKey = function () {
          lastCh = null;
        };

        ctrl.handleKeydown = function (e) {
          var ch;

          switch (e.keyCode) {
            case KEYS.UP:
              $scope.time = new Date($scope.time);
              selection.unit.increment($scope.time);
              $scope.$apply();
              ctrl.$$resetSelection(selection.start);
              break;
            case KEYS.DOWN:
              $scope.time = new Date($scope.time);
              selection.unit.decrement($scope.time);
              $scope.$apply();
              ctrl.$$resetSelection(selection.start);
              break;
            case KEYS.RIGHT:
              ctrl.moveRight();
              break;
            case KEYS.LEFT:
              ctrl.moveLeft();
              break;
          }

          if (e.keyCode !== KEYS.TAB) {
            e.preventDefault();
            e.stopImmediatePropagation();
          }

          ch = String.fromCharCode(e.keyCode);
          if (/([AaPp0-9])/.test(ch)) {
            if (!lastCh) {
              lastCh = '';
            }
            $scope.time = new Date($scope.time);
            lastCh = selection.unit.set($scope.time, lastCh + ch)
              ? ch
              : null;
            $scope.$apply();
            ctrl.$$resetSelection(selection.start);
            if (resetKeyTimeoutPromise) {
              $timeout.cancel(resetKeyTimeoutPromise);
            }
            resetKeyTimeoutPromise = $timeout(ctrl.$$resetLastKey,
              RESET_KEY_DELAY_MS, false);
          } else {
            lastCh = null;
          }
        };
      }],
      require: ['dzInputTime', 'ngModel'],
      link: function ($scope, $element, $attrs, ctrls) {
        var
          ctrl = ctrls[0],
          ngModel = ctrls[1];

        ngModel.$formatters.push(function (modelValue) {
          return dateFilter(modelValue, ctrl.options.format);
        });

        // we have no support for parsing right now...
        // ngModel.$parsers.push(function (viewValue) {
        //   return timeParser.parse(viewValue);
        // });

        // handle keyboard shortcuts
        $element.on('keydown', ctrl.handleKeydown);

        // when the cursor changes position,
        // reselect the correct unit
        $element.on('click focus', ctrl.refocus);
      }
    };
  }];

  angular.module('dz.inputTime', [])
    .factory('dzInputTimeUnits', timeUnitsFactory)
    .factory('dzInputTimeParser', timeParserFactory)
    .directive('dzInputTime', timeDirective);

})();


text:
package com.belladati.sdk.dashboard.impl;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;

import com.belladati.sdk.dashboard.Dashboard;
import com.belladati.sdk.dashboard.Dashlet;
import com.belladati.sdk.exception.impl.DashletException;
import com.belladati.sdk.impl.BellaDatiServiceImpl;
import com.belladati.sdk.util.impl.BellaDatiSdkUtils;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ArrayNode;

public class DashboardImpl implements Dashboard {

	private final BellaDatiServiceImpl service;

	private final String id;
	private final String name;
	private final Date lastChange;
	private final List<Dashlet> dashlets;

	public DashboardImpl(BellaDatiServiceImpl service, JsonNode json) {
		this.service = service;

		this.id = json.get("id").asText();
		this.name = json.get("name").asText();

		if (json.hasNonNull("lastChange")) {
			this.lastChange = BellaDatiSdkUtils.parseJavaUtilDate(json.get("lastChange").asText());
		} else {
			this.lastChange = null;
		}

		List<Dashlet> dashlets = new ArrayList<Dashlet>();
		if (json.hasNonNull("dashlets") && json.get("dashlets") instanceof ArrayNode) {
			for (JsonNode view : (ArrayNode) json.get("dashlets")) {
				try {
					DashletImpl viewInfo = new DashletImpl(this.service, view);
					dashlets.add(viewInfo);
				} catch (DashletException e) {
					// nothing to do, just ignore the view
				}
			}
		}
		this.dashlets = Collections.unmodifiableList(dashlets);
	}

	@Override
	public String getId() {
		return id;
	}

	@Override
	public String getName() {
		return name;
	}

	@Override
	public Date getLastChange() {
		return lastChange != null ? (Date) lastChange.clone() : null;
	}

	@Override
	public List<Dashlet> getDashlets() {
		return dashlets;
	}

	@Override
	public String toString() {
		return name;
	}

	@Override
	public boolean equals(Object obj) {
		if (obj instanceof DashboardImpl) {
			return id.equals(((DashboardImpl) obj).id);
		}
		return false;
	}

	@Override
	public int hashCode() {
		return id.hashCode();
	}
}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloSLC.Models
{
    /// <summary>
    /// Represents a clickable item on the left hand menu
    /// </summary>
    public class MenuItem
    {
        public string Title {get;set;}
        public string Icon { get; set; }
        public string Target { get; set; }

        // default constructor
        public MenuItem()
        {
        }
    }
}


text:
package org.apache.dubbo.demo.consumer;

import org.apache.dubbo.config.ApplicationConfig;
import org.apache.dubbo.config.ReferenceConfig;
import org.apache.dubbo.config.RegistryConfig;
import org.apache.dubbo.config.bootstrap.DubboBootstrap;
import org.apache.dubbo.config.utils.ReferenceConfigCache;
import org.apache.dubbo.demo.DemoService;
import org.apache.dubbo.rpc.service.GenericService;

public class Application {
    public static void main(String[] args) {
        if (isClassic(args)) {
            runWithRefer();
        } else {
            runWithBootstrap();
        }
    }

    private static boolean isClassic(String[] args) {
        return args.length > 0 && "classic".equalsIgnoreCase(args[0]);
    }

    private static void runWithBootstrap() {
        ReferenceConfig<DemoService> reference = new ReferenceConfig<>();
        reference.setInterface(DemoService.class);
        reference.setGeneric("true");

        DubboBootstrap bootstrap = DubboBootstrap.getInstance();
        bootstrap.application(new ApplicationConfig("dubbo-demo-api-consumer"))
                .registry(new RegistryConfig("zookeeper://127.0.0.1:2181"))
                .reference(reference)
                .start();

        DemoService demoService = ReferenceConfigCache.getCache().get(reference);
        String message = demoService.sayHello("dubbo");
        System.out.println(message);

        // generic invoke
        GenericService genericService = (GenericService) demoService;
        Object genericInvokeResult = genericService.$invoke("sayHello", new String[] { String.class.getName() },
                new Object[] { "dubbo generic invoke" });
        System.out.println(genericInvokeResult);
    }

    private static void runWithRefer() {
        ReferenceConfig<DemoService> reference = new ReferenceConfig<>();
        reference.setApplication(new ApplicationConfig("dubbo-demo-api-consumer"));
        reference.setRegistry(new RegistryConfig("zookeeper://127.0.0.1:2181"));
        reference.setInterface(DemoService.class);
        DemoService service = reference.get();
        String message = service.sayHello("dubbo");
        System.out.println(message);
    }
}


text:
package org.openqa.selenium;

import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.greaterThanOrEqualTo;
import static org.hamcrest.Matchers.lessThanOrEqualTo;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assume.assumeFalse;
import static org.junit.Assume.assumeTrue;
import static org.openqa.selenium.Platform.ANDROID;
import static org.openqa.selenium.testing.Ignore.Driver.CHROME;
import static org.openqa.selenium.testing.Ignore.Driver.HTMLUNIT;
import static org.openqa.selenium.testing.Ignore.Driver.FIREFOX;
import static org.openqa.selenium.testing.Ignore.Driver.IE;
import static org.openqa.selenium.testing.Ignore.Driver.MARIONETTE;
import static org.openqa.selenium.testing.Ignore.Driver.PHANTOMJS;
import static org.openqa.selenium.testing.Ignore.Driver.SAFARI;

import org.junit.Test;
import org.openqa.selenium.internal.Locatable;
import org.openqa.selenium.testing.Ignore;
import org.openqa.selenium.testing.JUnit4TestBase;
import org.openqa.selenium.testing.JavascriptEnabled;
import org.openqa.selenium.testing.TestUtilities;

@Ignore(value = {HTMLUNIT, MARIONETTE},
        reason = "HtmlUnit: Getting coordinates requires rendering, others: not tested")
public class PositionAndSizeTest extends JUnit4TestBase {

  @Test
  public void testShouldGetCoordinatesOfAnElement() {
    driver.get(appServer.whereIs("coordinates_tests/simple_page.html"));
    assertThat(getLocationInViewPort(By.id("box")), is(new Point(10, 10)));
    assertThat(getLocationOnPage(By.id("box")), is(new Point(10, 10)));
  }

  @Test
  public void testShouldGetCoordinatesOfAnEmptyElement() {
    driver.get(appServer.whereIs("coordinates_tests/page_with_empty_element.html"));
    assertThat(getLocationInViewPort(By.id("box")), is(new Point(10, 10)));
    assertThat(getLocationOnPage(By.id("box")), is(new Point(10, 10)));
  }

  @Test
  public void testShouldGetCoordinatesOfATransparentElement() {
    driver.get(appServer.whereIs("coordinates_tests/page_with_transparent_element.html"));
    assertThat(getLocationInViewPort(By.id("box")), is(new Point(10, 10)));
    assertThat(getLocationOnPage(By.id("box")), is(new Point(10, 10)));
  }

  @Test
  public void testShouldGetCoordinatesOfAHiddenElement() {
    driver.get(appServer.whereIs("coordinates_tests/page_with_hidden_element.html"));
    assertThat(getLocationInViewPort(By.id("box")), is(new Point(10, 10)));
    assertThat(getLocationOnPage(By.id("box")), is(new Point(10, 10)));
  }

  @Test
  @Ignore(SAFARI)
  public void testShouldGetCoordinatesOfAnInvisibleElement() {
    driver.get(appServer.whereIs("coordinates_tests/page_with_invisible_element.html"));
    assertThat(getLocationInViewPort(By.id("box")), is(new Point(0, 0)));
    assertThat(getLocationOnPage(By.id("box")), is(new Point(0, 0)));
  }

  @Ignore(value = {SAFARI})
  @Test
  public void testShouldScrollPageAndGetCoordinatesOfAnElementThatIsOutOfViewPort() {
    assumeFalse(
        "window().getSize() is not implemented for Chrome for Android. "
        + "https://code.google.com/p/chromedriver/issues/detail?id=1005",
        TestUtilities.isChrome(driver) && TestUtilities.getEffectivePlatform(driver).is(ANDROID));
    driver.get(appServer.whereIs("coordinates_tests/page_with_element_out_of_view.html"));
    int windowHeight = driver.manage().window().getSize().getHeight();
    Point location = getLocationInViewPort(By.id("box"));
    assertThat(location.getX(), is(10));
    assertThat(location.getY(), greaterThanOrEqualTo(0));
    assertThat(location.getY(), lessThanOrEqualTo(windowHeight - 100));
    assertThat(getLocationOnPage(By.id("box")), is(new Point(10, 5010)));
  }

  @Test
  public void testShouldGetCoordinatesOfAnElementInAFrame() {
    driver.get(appServer.whereIs("coordinates_tests/element_in_frame.html"));
    driver.switchTo().frame("ifr");
    WebElement box = driver.findElement(By.id("box"));
    assertThat(box.getLocation(), is(new Point(10, 10)));
    assertThat(getLocationOnPage(By.id("box")), is(new Point(10, 10)));
  }

  @Ignore({SAFARI})
  @Test
  public void testShouldGetCoordinatesInViewPortOfAnElementInAFrame() {
    driver.get(appServer.whereIs("coordinates_tests/element_in_frame.html"));
    driver.switchTo().frame("ifr");
    assertThat(getLocationInViewPort(By.id("box")), is(new Point(25, 25)));
    assertThat(getLocationOnPage(By.id("box")), is(new Point(10, 10)));
  }

  @Ignore({SAFARI})
  @Test
  public void testShouldGetCoordinatesInViewPortOfAnElementInANestedFrame() {
    driver.get(appServer.whereIs("coordinates_tests/element_in_nested_frame.html"));
    driver.switchTo().frame("ifr");
    driver.switchTo().frame("ifr");
    assertThat(getLocationInViewPort(By.id("box")), is(new Point(40, 40)));
    assertThat(getLocationOnPage(By.id("box")), is(new Point(10, 10)));
  }

  @Ignore({FIREFOX, SAFARI})
  @Test
  public void testShouldGetCoordinatesOfAnElementWithFixedPosition() {
    assumeFalse("Ignoring fixed-position elements in IE6", TestUtilities.isIe6(driver));
    driver.get(appServer.whereIs("coordinates_tests/page_with_fixed_element.html"));
    assertThat(getLocationInViewPort(By.id("fixed")).getY(), is(0));
    assertThat(getLocationOnPage(By.id("fixed")).getY(), is(0));

    driver.findElement(By.id("bottom")).click();
    assertThat(getLocationInViewPort(By.id("fixed")).getY(), is(0));
    assertThat(getLocationOnPage(By.id("fixed")).getY(), greaterThan(0));
  }

  @JavascriptEnabled
  @Test
  public void testShouldCorrectlyIdentifyThatAnElementHasWidthAndHeight() {
    driver.get(pages.xhtmlTestPage);

    WebElement shrinko = driver.findElement(By.id("linkId"));
    Dimension size = shrinko.getSize();
    assertTrue("Width expected to be greater than 0", size.width > 0);
    assertTrue("Height expected to be greater than 0", size.height > 0);
  }

  // TODO: This test's value seems dubious at best. The CSS spec does not define how browsers
  // should handle sub-pixel rendering, and every browser seems to be different anyhow:
  // http://ejohn.org/blog/sub-pixel-problems-in-css/
  @JavascriptEnabled
  @Ignore({IE, CHROME, SAFARI, PHANTOMJS, MARIONETTE})
  // Reason for Chrome: WebKit bug 28804
  @Test
  public void testShouldHandleNonIntegerPositionAndSize() {
    driver.get(pages.rectanglesPage);

    WebElement r2 = driver.findElement(By.id("r2"));
    String left = r2.getCssValue("left");
    assertTrue("left (\"" + left + "\") should start with \"10.9\".", left.startsWith("10.9"));
    String top = r2.getCssValue("top");
    assertTrue("top (\"" + top + "\") should start with \"10.1\".", top.startsWith("10.1"));
    assertEquals(new Point(11, 10), r2.getLocation());
    String width = r2.getCssValue("width");
    assertTrue("width (\"" + left + "\") should start with \"48.6\".", width.startsWith("48.6"));
    String height = r2.getCssValue("height");
    assertTrue("height (\"" + left + "\") should start with \"49.3\".", height.startsWith("49.3"));
    assertEquals(r2.getSize(), new Dimension(49, 49));
  }

  private Point getLocationInViewPort(By locator) {
    WebElement element = driver.findElement(locator);
    return ((Locatable) element).getCoordinates().inViewPort();
  }

  private Point getLocationOnPage(By locator) {
    WebElement element = driver.findElement(locator);
    return ((Locatable) element).getCoordinates().onPage();
  }
}


text:
/**
 * @fileoverview Common utils for AST.
 * @author Gyandeep Singh
 */

"use strict";

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const esutils = require("esutils");
const espree = require("espree");
const lodash = require("lodash");
const {
    breakableTypePattern,
    createGlobalLinebreakMatcher,
    lineBreakPattern,
    shebangPattern
} = require("../../shared/ast-utils");

//------------------------------------------------------------------------------
// Helpers
//------------------------------------------------------------------------------

const anyFunctionPattern = /^(?:Function(?:Declaration|Expression)|ArrowFunctionExpression)$/u;
const anyLoopPattern = /^(?:DoWhile|For|ForIn|ForOf|While)Statement$/u;
const arrayOrTypedArrayPattern = /Array$/u;
const arrayMethodPattern = /^(?:every|filter|find|findIndex|forEach|map|some)$/u;
const bindOrCallOrApplyPattern = /^(?:bind|call|apply)$/u;
const thisTagPattern = /^[\s*]*@this/mu;

const COMMENTS_IGNORE_PATTERN = /^\s*(?:eslint|jshint\s+|jslint\s+|istanbul\s+|globals?\s+|exported\s+|jscs)/u;
const LINEBREAKS = new Set(["\r\n", "\r", "\n", "\u2028", "\u2029"]);

// A set of node types that can contain a list of statements
const STATEMENT_LIST_PARENTS = new Set(["Program", "BlockStatement", "SwitchCase"]);

const DECIMAL_INTEGER_PATTERN = /^(0|[1-9]\d*)$/u;
const OCTAL_ESCAPE_PATTERN = /^(?:[^\\]|\\[^0-7]|\\0(?![0-9]))*\\(?:[1-7]|0[0-9])/u;

/**
 * Checks reference if is non initializer and writable.
 * @param {Reference} reference A reference to check.
 * @param {int} index The index of the reference in the references.
 * @param {Reference[]} references The array that the reference belongs to.
 * @returns {boolean} Success/Failure
 * @private
 */
function isModifyingReference(reference, index, references) {
    const identifier = reference.identifier;

    /*
     * Destructuring assignments can have multiple default value, so
     * possibly there are multiple writeable references for the same
     * identifier.
     */
    const modifyingDifferentIdentifier = index === 0 ||
        references[index - 1].identifier !== identifier;

    return (identifier &&
        reference.init === false &&
        reference.isWrite() &&
        modifyingDifferentIdentifier
    );
}

/**
 * Checks whether the given string starts with uppercase or not.
 * @param {string} s The string to check.
 * @returns {boolean} `true` if the string starts with uppercase.
 */
function startsWithUpperCase(s) {
    return s[0] !== s[0].toLocaleLowerCase();
}

/**
 * Checks whether or not a node is a constructor.
 * @param {ASTNode} node A function node to check.
 * @returns {boolean} Wehether or not a node is a constructor.
 */
function isES5Constructor(node) {
    return (node.id && startsWithUpperCase(node.id.name));
}

/**
 * Finds a function node from ancestors of a node.
 * @param {ASTNode} node A start node to find.
 * @returns {Node|null} A found function node.
 */
function getUpperFunction(node) {
    for (let currentNode = node; currentNode; currentNode = currentNode.parent) {
        if (anyFunctionPattern.test(currentNode.type)) {
            return currentNode;
        }
    }
    return null;
}

/**
 * Checks whether a given node is a function node or not.
 * The following types are function nodes:
 *
 * - ArrowFunctionExpression
 * - FunctionDeclaration
 * - FunctionExpression
 * @param {ASTNode|null} node A node to check.
 * @returns {boolean} `true` if the node is a function node.
 */
function isFunction(node) {
    return Boolean(node && anyFunctionPattern.test(node.type));
}

/**
 * Checks whether a given node is a loop node or not.
 * The following types are loop nodes:
 *
 * - DoWhileStatement
 * - ForInStatement
 * - ForOfStatement
 * - ForStatement
 * - WhileStatement
 * @param {ASTNode|null} node A node to check.
 * @returns {boolean} `true` if the node is a loop node.
 */
function isLoop(node) {
    return Boolean(node && anyLoopPattern.test(node.type));
}

/**
 * Checks whether the given node is in a loop or not.
 * @param {ASTNode} node The node to check.
 * @returns {boolean} `true` if the node is in a loop.
 */
function isInLoop(node) {
    for (let currentNode = node; currentNode && !isFunction(currentNode); currentNode = currentNode.parent) {
        if (isLoop(currentNode)) {
            return true;
        }
    }

    return false;
}

/**
 * Checks whether or not a node is `null` or `undefined`.
 * @param {ASTNode} node A node to check.
 * @returns {boolean} Whether or not the node is a `null` or `undefined`.
 * @public
 */
function isNullOrUndefined(node) {
    return (
        module.exports.isNullLiteral(node) ||
        (node.type === "Identifier" && node.name === "undefined") ||
        (node.type === "UnaryExpression" && node.operator === "void")
    );
}

/**
 * Checks whether or not a node is callee.
 * @param {ASTNode} node A node to check.
 * @returns {boolean} Whether or not the node is callee.
 */
function isCallee(node) {
    return node.parent.type === "CallExpression" && node.parent.callee === node;
}

/**
 * Checks whether or not a node is `Reflect.apply`.
 * @param {ASTNode} node A node to check.
 * @returns {boolean} Whether or not the node is a `Reflect.apply`.
 */
function isReflectApply(node) {
    return (
        node.type === "MemberExpression" &&
        node.object.type === "Identifier" &&
        node.object.name === "Reflect" &&
        node.property.type === "Identifier" &&
        node.property.name === "apply" &&
        node.computed === false
    );
}

/**
 * Checks whether or not a node is `Array.from`.
 * @param {ASTNode} node A node to check.
 * @returns {boolean} Whether or not the node is a `Array.from`.
 */
function isArrayFromMethod(node) {
    return (
        node.type === "MemberExpression" &&
        node.object.type === "Identifier" &&
        arrayOrTypedArrayPattern.test(node.object.name) &&
        node.property.type === "Identifier" &&
        node.property.name === "from" &&
        node.computed === false
    );
}

/**
 * Checks whether or not a node is a method which has `thisArg`.
 * @param {ASTNode} node A node to check.
 * @returns {boolean} Whether or not the node is a method which has `thisArg`.
 */
function isMethodWhichHasThisArg(node) {
    for (
        let currentNode = node;
        currentNode.type === "MemberExpression" && !currentNode.computed;
        currentNode = currentNode.property
    ) {
        if (currentNode.property.type === "Identifier") {
            return arrayMethodPattern.test(currentNode.property.name);
        }
    }

    return false;
}

/**
 * Creates the negate function of the given function.
 * @param {Function} f The function to negate.
 * @returns {Function} Negated function.
 */
function negate(f) {
    return token => !f(token);
}

/**
 * Checks whether or not a node has a `@this` tag in its comments.
 * @param {ASTNode} node A node to check.
 * @param {SourceCode} sourceCode A SourceCode instance to get comments.
 * @returns {boolean} Whether or not the node has a `@this` tag in its comments.
 */
function hasJSDocThisTag(node, sourceCode) {
    const jsdocComment = sourceCode.getJSDocComment(node);

    if (jsdocComment && thisTagPattern.test(jsdocComment.value)) {
        return true;
    }

    // Checks `@this` in its leading comments for callbacks,
    // because callbacks don't have its JSDoc comment.
    // e.g.
    //     sinon.test(/* @this sinon.Sandbox */function() { this.spy(); });
    return sourceCode.getCommentsBefore(node).some(comment => thisTagPattern.test(comment.value));
}

/**
 * Determines if a node is surrounded by parentheses.
 * @param {SourceCode} sourceCode The ESLint source code object
 * @param {ASTNode} node The node to be checked.
 * @returns {boolean} True if the node is parenthesised.
 * @private
 */
function isParenthesised(sourceCode, node) {
    const previousToken = sourceCode.getTokenBefore(node),
        nextToken = sourceCode.getTokenAfter(node);

    return Boolean(previousToken && nextToken) &&
        previousToken.value === "(" && previousToken.range[1] <= node.range[0] &&
        nextToken.value === ")" && nextToken.range[0] >= node.range[1];
}

/**
 * Checks if the given token is an arrow token or not.
 * @param {Token} token The token to check.
 * @returns {boolean} `true` if the token is an arrow token.
 */
function isArrowToken(token) {
    return token.value === "=>" && token.type === "Punctuator";
}

/**
 * Checks if the given token is a comma token or not.
 * @param {Token} token The token to check.
 * @returns {boolean} `true` if the token is a comma token.
 */
function isCommaToken(token) {
    return token.value === "," && token.type === "Punctuator";
}

/**
 * Checks if the given token is a dot token or not.
 * @param {Token} token The token to check.
 * @returns {boolean} `true` if the token is a dot token.
 */
function isDotToken(token) {
    return token.value === "." && token.type === "Punctuator";
}

/**
 * Checks if the given token is a semicolon token or not.
 * @param {Token} token The token to check.
 * @returns {boolean} `true` if the token is a semicolon token.
 */
function isSemicolonToken(token) {
    return token.value === ";" && token.type === "Punctuator";
}

/**
 * Checks if the given token is a colon token or not.
 * @param {Token} token The token to check.
 * @returns {boolean} `true` if the token is a colon token.
 */
function isColonToken(token) {
    return token.value === ":" && token.type === "Punctuator";
}

/**
 * Checks if the given token is an opening parenthesis token or not.
 * @param {Token} token The token to check.
 * @returns {boolean} `true` if the token is an opening parenthesis token.
 */
function isOpeningParenToken(token) {
    return token.value === "(" && token.type === "Punctuator";
}

/**
 * Checks if the given token is a closing parenthesis token or not.
 * @param {Token} token The token to check.
 * @returns {boolean} `true` if the token is a closing parenthesis token.
 */
function isClosingParenToken(token) {
    return token.value === ")" && token.type === "Punctuator";
}

/**
 * Checks if the given token is an opening square bracket token or not.
 * @param {Token} token The token to check.
 * @returns {boolean} `true` if the token is an opening square bracket token.
 */
function isOpeningBracketToken(token) {
    return token.value === "[" && token.type === "Punctuator";
}

/**
 * Checks if the given token is a closing square bracket token or not.
 * @param {Token} token The token to check.
 * @returns {boolean} `true` if the token is a closing square bracket token.
 */
function isClosingBracketToken(token) {
    return token.value === "]" && token.type === "Punctuator";
}

/**
 * Checks if the given token is an opening brace token or not.
 * @param {Token} token The token to check.
 * @returns {boolean} `true` if the token is an opening brace token.
 */
function isOpeningBraceToken(token) {
    return token.value === "{" && token.type === "Punctuator";
}

/**
 * Checks if the given token is a closing brace token or not.
 * @param {Token} token The token to check.
 * @returns {boolean} `true` if the token is a closing brace token.
 */
function isClosingBraceToken(token) {
    return token.value === "}" && token.type === "Punctuator";
}

/**
 * Checks if the given token is a comment token or not.
 * @param {Token} token The token to check.
 * @returns {boolean} `true` if the token is a comment token.
 */
function isCommentToken(token) {
    return token.type === "Line" || token.type === "Block" || token.type === "Shebang";
}

/**
 * Checks if the given token is a keyword token or not.
 * @param {Token} token The token to check.
 * @returns {boolean} `true` if the token is a keyword token.
 */
function isKeywordToken(token) {
    return token.type === "Keyword";
}

/**
 * Gets the `(` token of the given function node.
 * @param {ASTNode} node The function node to get.
 * @param {SourceCode} sourceCode The source code object to get tokens.
 * @returns {Token} `(` token.
 */
function getOpeningParenOfParams(node, sourceCode) {
    return node.id
        ? sourceCode.getTokenAfter(node.id, isOpeningParenToken)
        : sourceCode.getFirstToken(node, isOpeningParenToken);
}

/**
 * Checks whether or not the tokens of two given nodes are same.
 * @param {ASTNode} left A node 1 to compare.
 * @param {ASTNode} right A node 2 to compare.
 * @param {SourceCode} sourceCode The ESLint source code object.
 * @returns {boolean} the source code for the given node.
 */
function equalTokens(left, right, sourceCode) {
    const tokensL = sourceCode.getTokens(left);
    const tokensR = sourceCode.getTokens(right);

    if (tokensL.length !== tokensR.length) {
        return false;
    }
    for (let i = 0; i < tokensL.length; ++i) {
        if (tokensL[i].type !== tokensR[i].type ||
            tokensL[i].value !== tokensR[i].value
        ) {
            return false;
        }
    }

    return true;
}

//------------------------------------------------------------------------------
// Public Interface
//------------------------------------------------------------------------------

module.exports = {
    COMMENTS_IGNORE_PATTERN,
    LINEBREAKS,
    LINEBREAK_MATCHER: lineBreakPattern,
    SHEBANG_MATCHER: shebangPattern,
    STATEMENT_LIST_PARENTS,

    /**
     * Determines whether two adjacent tokens are on the same line.
     * @param {Object} left The left token object.
     * @param {Object} right The right token object.
     * @returns {boolean} Whether or not the tokens are on the same line.
     * @public
     */
    isTokenOnSameLine(left, right) {
        return left.loc.end.line === right.loc.start.line;
    },

    isNullOrUndefined,
    isCallee,
    isES5Constructor,
    getUpperFunction,
    isFunction,
    isLoop,
    isInLoop,
    isArrayFromMethod,
    isParenthesised,
    createGlobalLinebreakMatcher,
    equalTokens,

    isArrowToken,
    isClosingBraceToken,
    isClosingBracketToken,
    isClosingParenToken,
    isColonToken,
    isCommaToken,
    isCommentToken,
    isDotToken,
    isKeywordToken,
    isNotClosingBraceToken: negate(isClosingBraceToken),
    isNotClosingBracketToken: negate(isClosingBracketToken),
    isNotClosingParenToken: negate(isClosingParenToken),
    isNotColonToken: negate(isColonToken),
    isNotCommaToken: negate(isCommaToken),
    isNotDotToken: negate(isDotToken),
    isNotOpeningBraceToken: negate(isOpeningBraceToken),
    isNotOpeningBracketToken: negate(isOpeningBracketToken),
    isNotOpeningParenToken: negate(isOpeningParenToken),
    isNotSemicolonToken: negate(isSemicolonToken),
    isOpeningBraceToken,
    isOpeningBracketToken,
    isOpeningParenToken,
    isSemicolonToken,

    /**
     * Checks whether or not a given node is a string literal.
     * @param {ASTNode} node A node to check.
     * @returns {boolean} `true` if the node is a string literal.
     */
    isStringLiteral(node) {
        return (
            (node.type === "Literal" && typeof node.value === "string") ||
            node.type === "TemplateLiteral"
        );
    },

    /**
     * Checks whether a given node is a breakable statement or not.
     * The node is breakable if the node is one of the following type:
     *
     * - DoWhileStatement
     * - ForInStatement
     * - ForOfStatement
     * - ForStatement
     * - SwitchStatement
     * - WhileStatement
     * @param {ASTNode} node A node to check.
     * @returns {boolean} `true` if the node is breakable.
     */
    isBreakableStatement(node) {
        return breakableTypePattern.test(node.type);
    },

    /**
     * Gets references which are non initializer and writable.
     * @param {Reference[]} references An array of references.
     * @returns {Reference[]} An array of only references which are non initializer and writable.
     * @public
     */
    getModifyingReferences(references) {
        return references.filter(isModifyingReference);
    },

    /**
     * Validate that a string passed in is surrounded by the specified character
     * @param  {string} val The text to check.
     * @param  {string} character The character to see if it's surrounded by.
     * @returns {boolean} True if the text is surrounded by the character, false if not.
     * @private
     */
    isSurroundedBy(val, character) {
        return val[0] === character && val[val.length - 1] === character;
    },

    /**
     * Returns whether the provided node is an ESLint directive comment or not
     * @param {Line|Block} node The comment token to be checked
     * @returns {boolean} `true` if the node is an ESLint directive comment
     */
    isDirectiveComment(node) {
        const comment = node.value.trim();

        return (
            node.type === "Line" && comment.indexOf("eslint-") === 0 ||
            node.type === "Block" && (
                comment.indexOf("global ") === 0 ||
                comment.indexOf("eslint ") === 0 ||
                comment.indexOf("eslint-") === 0
            )
        );
    },

    /**
     * Gets the trailing statement of a given node.
     *
     *     if (code)
     *         consequent;
     *
     * When taking this `IfStatement`, returns `consequent;` statement.
     * @param {ASTNode} A node to get.
     * @returns {ASTNode|null} The trailing statement's node.
     */
    getTrailingStatement: esutils.ast.trailingStatement,

    /**
     * Finds the variable by a given name in a given scope and its upper scopes.
     * @param {eslint-scope.Scope} initScope A scope to start find.
     * @param {string} name A variable name to find.
     * @returns {eslint-scope.Variable|null} A found variable or `null`.
     */
    getVariableByName(initScope, name) {
        let scope = initScope;

        while (scope) {
            const variable = scope.set.get(name);

            if (variable) {
                return variable;
            }

            scope = scope.upper;
        }

        return null;
    },

    /**
     * Checks whether or not a given function node is the default `this` binding.
     *
     * First, this checks the node:
     *
     * - The function name does not start with uppercase. It's a convention to capitalize the names
     *   of constructor functions. This check is not performed if `capIsConstructor` is set to `false`.
     * - The function does not have a JSDoc comment that has a @this tag.
     *
     * Next, this checks the location of the node.
     * If the location is below, this judges `this` is valid.
     *
     * - The location is not on an object literal.
     * - The location is not assigned to a variable which starts with an uppercase letter. Applies to anonymous
     *   functions only, as the name of the variable is considered to be the name of the function in this case.
     *   This check is not performed if `capIsConstructor` is set to `false`.
     * - The location is not on an ES2015 class.
     * - Its `bind`/`call`/`apply` method is not called directly.
     * - The function is not a callback of array methods (such as `.forEach()`) if `thisArg` is given.
     * @param {ASTNode} node A function node to check.
     * @param {SourceCode} sourceCode A SourceCode instance to get comments.
     * @param {boolean} [capIsConstructor = true] `false` disables the assumption that functions which name starts
     * with an uppercase or are assigned to a variable which name starts with an uppercase are constructors.
     * @returns {boolean} The function node is the default `this` binding.
     */
    isDefaultThisBinding(node, sourceCode, { capIsConstructor = true } = {}) {
        if (
            (capIsConstructor && isES5Constructor(node)) ||
            hasJSDocThisTag(node, sourceCode)
        ) {
            return false;
        }
        const isAnonymous = node.id === null;
        let currentNode = node;

        while (currentNode) {
            const parent = currentNode.parent;

            switch (parent.type) {

                /*
                 * Looks up the destination.
                 * e.g., obj.foo = nativeFoo || function foo() { ... };
                 */
                case "LogicalExpression":
                case "ConditionalExpression":
                    currentNode = parent;
                    break;

                /*
                 * If the upper function is IIFE, checks the destination of the return value.
                 * e.g.
                 *   obj.foo = (function() {
                 *     // setup...
                 *     return function foo() { ... };
                 *   })();
                 *   obj.foo = (() =>
                 *     function foo() { ... }
                 *   )();
                 */
                case "ReturnStatement": {
                    const func = getUpperFunction(parent);

                    if (func === null || !isCallee(func)) {
                        return true;
                    }
                    currentNode = func.parent;
                    break;
                }
                case "ArrowFunctionExpression":
                    if (currentNode !== parent.body || !isCallee(parent)) {
                        return true;
                    }
                    currentNode = parent.parent;
                    break;

                /*
                 * e.g.
                 *   var obj = { foo() { ... } };
                 *   var obj = { foo: function() { ... } };
                 *   class A { constructor() { ... } }
                 *   class A { foo() { ... } }
                 *   class A { get foo() { ... } }
                 *   class A { set foo() { ... } }
                 *   class A { static foo() { ... } }
                 */
                case "Property":
                case "MethodDefinition":
                    return parent.value !== currentNode;

                /*
                 * e.g.
                 *   obj.foo = function foo() { ... };
                 *   Foo = function() { ... };
                 *   [obj.foo = function foo() { ... }] = a;
                 *   [Foo = function() { ... }] = a;
                 */
                case "AssignmentExpression":
                case "AssignmentPattern":
                    if (parent.left.type === "MemberExpression") {
                        return false;
                    }
                    if (
                        capIsConstructor &&
                        isAnonymous &&
                        parent.left.type === "Identifier" &&
                        startsWithUpperCase(parent.left.name)
                    ) {
                        return false;
                    }
                    return true;

                /*
                 * e.g.
                 *   var Foo = function() { ... };
                 */
                case "VariableDeclarator":
                    return !(
                        capIsConstructor &&
                        isAnonymous &&
                        parent.init === currentNode &&
                        parent.id.type === "Identifier" &&
                        startsWithUpperCase(parent.id.name)
                    );

                /*
                 * e.g.
                 *   var foo = function foo() { ... }.bind(obj);
                 *   (function foo() { ... }).call(obj);
                 *   (function foo() { ... }).apply(obj, []);
                 */
                case "MemberExpression":
                    return (
                        parent.object !== currentNode ||
                        parent.property.type !== "Identifier" ||
                        !bindOrCallOrApplyPattern.test(parent.property.name) ||
                        !isCallee(parent) ||
                        parent.parent.arguments.length === 0 ||
                        isNullOrUndefined(parent.parent.arguments[0])
                    );

                /*
                 * e.g.
                 *   Reflect.apply(function() {}, obj, []);
                 *   Array.from([], function() {}, obj);
                 *   list.forEach(function() {}, obj);
                 */
                case "CallExpression":
                    if (isReflectApply(parent.callee)) {
                        return (
                            parent.arguments.length !== 3 ||
                            parent.arguments[0] !== currentNode ||
                            isNullOrUndefined(parent.arguments[1])
                        );
                    }
                    if (isArrayFromMethod(parent.callee)) {
                        return (
                            parent.arguments.length !== 3 ||
                            parent.arguments[1] !== currentNode ||
                            isNullOrUndefined(parent.arguments[2])
                        );
                    }
                    if (isMethodWhichHasThisArg(parent.callee)) {
                        return (
                            parent.arguments.length !== 2 ||
                            parent.arguments[0] !== currentNode ||
                            isNullOrUndefined(parent.arguments[1])
                        );
                    }
                    return true;

                // Otherwise `this` is default.
                default:
                    return true;
            }
        }

        /* istanbul ignore next */
        return true;
    },

    /**
     * Get the precedence level based on the node type
     * @param {ASTNode} node node to evaluate
     * @returns {int} precedence level
     * @private
     */
    getPrecedence(node) {
        switch (node.type) {
            case "SequenceExpression":
                return 0;

            case "AssignmentExpression":
            case "ArrowFunctionExpression":
            case "YieldExpression":
                return 1;

            case "ConditionalExpression":
                return 3;

            case "LogicalExpression":
                switch (node.operator) {
                    case "||":
                        return 4;
                    case "&&":
                        return 5;

                    // no default
                }

                /* falls through */

            case "BinaryExpression":

                switch (node.operator) {
                    case "|":
                        return 6;
                    case "^":
                        return 7;
                    case "&":
                        return 8;
                    case "==":
                    case "!=":
                    case "===":
                    case "!==":
                        return 9;
                    case "<":
                    case "<=":
                    case ">":
                    case ">=":
                    case "in":
                    case "instanceof":
                        return 10;
                    case "<<":
                    case ">>":
                    case ">>>":
                        return 11;
                    case "+":
                    case "-":
                        return 12;
                    case "*":
                    case "/":
                    case "%":
                        return 13;
                    case "**":
                        return 15;

                    // no default
                }

                /* falls through */

            case "UnaryExpression":
            case "AwaitExpression":
                return 16;

            case "UpdateExpression":
                return 17;

            case "CallExpression":
            case "ImportExpression":
                return 18;

            case "NewExpression":
                return 19;

            default:
                return 20;
        }
    },

    /**
     * Checks whether the given node is an empty block node or not.
     * @param {ASTNode|null} node The node to check.
     * @returns {boolean} `true` if the node is an empty block.
     */
    isEmptyBlock(node) {
        return Boolean(node && node.type === "BlockStatement" && node.body.length === 0);
    },

    /**
     * Checks whether the given node is an empty function node or not.
     * @param {ASTNode|null} node The node to check.
     * @returns {boolean} `true` if the node is an empty function.
     */
    isEmptyFunction(node) {
        return isFunction(node) && module.exports.isEmptyBlock(node.body);
    },

    /**
     * Gets the property name of a given node.
     * The node can be a MemberExpression, a Property, or a MethodDefinition.
     *
     * If the name is dynamic, this returns `null`.
     *
     * For examples:
     *
     *     a.b           // => "b"
     *     a["b"]        // => "b"
     *     a['b']        // => "b"
     *     a[`b`]        // => "b"
     *     a[100]        // => "100"
     *     a[b]          // => null
     *     a["a" + "b"]  // => null
     *     a[tag`b`]     // => null
     *     a[`${b}`]     // => null
     *
     *     let a = {b: 1}            // => "b"
     *     let a = {["b"]: 1}        // => "b"
     *     let a = {['b']: 1}        // => "b"
     *     let a = {[`b`]: 1}        // => "b"
     *     let a = {[100]: 1}        // => "100"
     *     let a = {[b]: 1}          // => null
     *     let a = {["a" + "b"]: 1}  // => null
     *     let a = {[tag`b`]: 1}     // => null
     *     let a = {[`${b}`]: 1}     // => null
     * @param {ASTNode} node The node to get.
     * @returns {string|null} The property name if static. Otherwise, null.
     */
    getStaticPropertyName(node) {
        let prop;

        switch (node && node.type) {
            case "Property":
            case "MethodDefinition":
                prop = node.key;
                break;

            case "MemberExpression":
                prop = node.property;
                break;

            // no default
        }

        switch (prop && prop.type) {
            case "Literal":
                return String(prop.value);

            case "TemplateLiteral":
                if (prop.expressions.length === 0 && prop.quasis.length === 1) {
                    return prop.quasis[0].value.cooked;
                }
                break;

            case "Identifier":
                if (!node.computed) {
                    return prop.name;
                }
                break;

            // no default
        }

        return null;
    },

    /**
     * Get directives from directive prologue of a Program or Function node.
     * @param {ASTNode} node The node to check.
     * @returns {ASTNode[]} The directives found in the directive prologue.
     */
    getDirectivePrologue(node) {
        const directives = [];

        // Directive prologues only occur at the top of files or functions.
        if (
            node.type === "Program" ||
            node.type === "FunctionDeclaration" ||
            node.type === "FunctionExpression" ||

            /*
             * Do not check arrow functions with implicit return.
             * `() => "use strict";` returns the string `"use strict"`.
             */
            (node.type === "ArrowFunctionExpression" && node.body.type === "BlockStatement")
        ) {
            const statements = node.type === "Program" ? node.body : node.body.body;

            for (const statement of statements) {
                if (
                    statement.type === "ExpressionStatement" &&
                    statement.expression.type === "Literal"
                ) {
                    directives.push(statement);
                } else {
                    break;
                }
            }
        }

        return directives;
    },

    /**
     * Determines whether this node is a decimal integer literal. If a node is a decimal integer literal, a dot added
     * after the node will be parsed as a decimal point, rather than a property-access dot.
     * @param {ASTNode} node The node to check.
     * @returns {boolean} `true` if this node is a decimal integer.
     * @example
     *
     * 5       // true
     * 5.      // false
     * 5.0     // false
     * 05      // false
     * 0x5     // false
     * 0b101   // false
     * 0o5     // false
     * 5e0     // false
     * '5'     // false
     */
    isDecimalInteger(node) {
        return node.type === "Literal" && typeof node.value === "number" &&
            DECIMAL_INTEGER_PATTERN.test(node.raw);
    },

    /**
     * Determines whether this token is a decimal integer numeric token.
     * This is similar to isDecimalInteger(), but for tokens.
     * @param {Token} token The token to check.
     * @returns {boolean} `true` if this token is a decimal integer.
     */
    isDecimalIntegerNumericToken(token) {
        return token.type === "Numeric" && DECIMAL_INTEGER_PATTERN.test(token.value);
    },

    /**
     * Gets the name and kind of the given function node.
     *
     * - `function foo() {}`  .................... `function 'foo'`
     * - `(function foo() {})`  .................. `function 'foo'`
     * - `(function() {})`  ...................... `function`
     * - `function* foo() {}`  ................... `generator function 'foo'`
     * - `(function* foo() {})`  ................. `generator function 'foo'`
     * - `(function*() {})`  ..................... `generator function`
     * - `() => {}`  ............................. `arrow function`
     * - `async () => {}`  ....................... `async arrow function`
     * - `({ foo: function foo() {} })`  ......... `method 'foo'`
     * - `({ foo: function() {} })`  ............. `method 'foo'`
     * - `({ ['foo']: function() {} })`  ......... `method 'foo'`
     * - `({ [foo]: function() {} })`  ........... `method`
     * - `({ foo() {} })`  ....................... `method 'foo'`
     * - `({ foo: function* foo() {} })`  ........ `generator method 'foo'`
     * - `({ foo: function*() {} })`  ............ `generator method 'foo'`
     * - `({ ['foo']: function*() {} })`  ........ `generator method 'foo'`
     * - `({ [foo]: function*() {} })`  .......... `generator method`
     * - `({ *foo() {} })`  ...................... `generator method 'foo'`
     * - `({ foo: async function foo() {} })`  ... `async method 'foo'`
     * - `({ foo: async function() {} })`  ....... `async method 'foo'`
     * - `({ ['foo']: async function() {} })`  ... `async method 'foo'`
     * - `({ [foo]: async function() {} })`  ..... `async method`
     * - `({ async foo() {} })`  ................. `async method 'foo'`
     * - `({ get foo() {} })`  ................... `getter 'foo'`
     * - `({ set foo(a) {} })`  .................. `setter 'foo'`
     * - `class A { constructor() {} }`  ......... `constructor`
     * - `class A { foo() {} }`  ................. `method 'foo'`
     * - `class A { *foo() {} }`  ................ `generator method 'foo'`
     * - `class A { async foo() {} }`  ........... `async method 'foo'`
     * - `class A { ['foo']() {} }`  ............. `method 'foo'`
     * - `class A { *['foo']() {} }`  ............ `generator method 'foo'`
     * - `class A { async ['foo']() {} }`  ....... `async method 'foo'`
     * - `class A { [foo]() {} }`  ............... `method`
     * - `class A { *[foo]() {} }`  .............. `generator method`
     * - `class A { async [foo]() {} }`  ......... `async method`
     * - `class A { get foo() {} }`  ............. `getter 'foo'`
     * - `class A { set foo(a) {} }`  ............ `setter 'foo'`
     * - `class A { static foo() {} }`  .......... `static method 'foo'`
     * - `class A { static *foo() {} }`  ......... `static generator method 'foo'`
     * - `class A { static async foo() {} }`  .... `static async method 'foo'`
     * - `class A { static get foo() {} }`  ...... `static getter 'foo'`
     * - `class A { static set foo(a) {} }`  ..... `static setter 'foo'`
     * @param {ASTNode} node The function node to get.
     * @returns {string} The name and kind of the function node.
     */
    getFunctionNameWithKind(node) {
        const parent = node.parent;
        const tokens = [];

        if (parent.type === "MethodDefinition" && parent.static) {
            tokens.push("static");
        }
        if (node.async) {
            tokens.push("async");
        }
        if (node.generator) {
            tokens.push("generator");
        }

        if (node.type === "ArrowFunctionExpression") {
            tokens.push("arrow", "function");
        } else if (parent.type === "Property" || parent.type === "MethodDefinition") {
            if (parent.kind === "constructor") {
                return "constructor";
            }
            if (parent.kind === "get") {
                tokens.push("getter");
            } else if (parent.kind === "set") {
                tokens.push("setter");
            } else {
                tokens.push("method");
            }
        } else {
            tokens.push("function");
        }

        if (node.id) {
            tokens.push(`'${node.id.name}'`);
        } else {
            const name = module.exports.getStaticPropertyName(parent);

            if (name !== null) {
                tokens.push(`'${name}'`);
            }
        }

        return tokens.join(" ");
    },

    /**
     * Gets the location of the given function node for reporting.
     *
     * - `function foo() {}`
     *    ^^^^^^^^^^^^
     * - `(function foo() {})`
     *     ^^^^^^^^^^^^
     * - `(function() {})`
     *     ^^^^^^^^
     * - `function* foo() {}`
     *    ^^^^^^^^^^^^^
     * - `(function* foo() {})`
     *     ^^^^^^^^^^^^^
     * - `(function*() {})`
     *     ^^^^^^^^^
     * - `() => {}`
     *       ^^
     * - `async () => {}`
     *             ^^
     * - `({ foo: function foo() {} })`
     *       ^^^^^^^^^^^^^^^^^
     * - `({ foo: function() {} })`
     *       ^^^^^^^^^^^^^
     * - `({ ['foo']: function() {} })`
     *       ^^^^^^^^^^^^^^^^^
     * - `({ [foo]: function() {} })`
     *       ^^^^^^^^^^^^^^^
     * - `({ foo() {} })`
     *       ^^^
     * - `({ foo: function* foo() {} })`
     *       ^^^^^^^^^^^^^^^^^^
     * - `({ foo: function*() {} })`
     *       ^^^^^^^^^^^^^^
     * - `({ ['foo']: function*() {} })`
     *       ^^^^^^^^^^^^^^^^^^
     * - `({ [foo]: function*() {} })`
     *       ^^^^^^^^^^^^^^^^
     * - `({ *foo() {} })`
     *       ^^^^
     * - `({ foo: async function foo() {} })`
     *       ^^^^^^^^^^^^^^^^^^^^^^^
     * - `({ foo: async function() {} })`
     *       ^^^^^^^^^^^^^^^^^^^
     * - `({ ['foo']: async function() {} })`
     *       ^^^^^^^^^^^^^^^^^^^^^^^
     * - `({ [foo]: async function() {} })`
     *       ^^^^^^^^^^^^^^^^^^^^^
     * - `({ async foo() {} })`
     *       ^^^^^^^^^
     * - `({ get foo() {} })`
     *       ^^^^^^^
     * - `({ set foo(a) {} })`
     *       ^^^^^^^
     * - `class A { constructor() {} }`
     *              ^^^^^^^^^^^
     * - `class A { foo() {} }`
     *              ^^^
     * - `class A { *foo() {} }`
     *              ^^^^
     * - `class A { async foo() {} }`
     *              ^^^^^^^^^
     * - `class A { ['foo']() {} }`
     *              ^^^^^^^
     * - `class A { *['foo']() {} }`
     *              ^^^^^^^^
     * - `class A { async ['foo']() {} }`
     *              ^^^^^^^^^^^^^
     * - `class A { [foo]() {} }`
     *              ^^^^^
     * - `class A { *[foo]() {} }`
     *              ^^^^^^
     * - `class A { async [foo]() {} }`
     *              ^^^^^^^^^^^
     * - `class A { get foo() {} }`
     *              ^^^^^^^
     * - `class A { set foo(a) {} }`
     *              ^^^^^^^
     * - `class A { static foo() {} }`
     *              ^^^^^^^^^^
     * - `class A { static *foo() {} }`
     *              ^^^^^^^^^^^
     * - `class A { static async foo() {} }`
     *              ^^^^^^^^^^^^^^^^
     * - `class A { static get foo() {} }`
     *              ^^^^^^^^^^^^^^
     * - `class A { static set foo(a) {} }`
     *              ^^^^^^^^^^^^^^
     * @param {ASTNode} node The function node to get.
     * @param {SourceCode} sourceCode The source code object to get tokens.
     * @returns {string} The location of the function node for reporting.
     */
    getFunctionHeadLoc(node, sourceCode) {
        const parent = node.parent;
        let start = null;
        let end = null;

        if (node.type === "ArrowFunctionExpression") {
            const arrowToken = sourceCode.getTokenBefore(node.body, isArrowToken);

            start = arrowToken.loc.start;
            end = arrowToken.loc.end;
        } else if (parent.type === "Property" || parent.type === "MethodDefinition") {
            start = parent.loc.start;
            end = getOpeningParenOfParams(node, sourceCode).loc.start;
        } else {
            start = node.loc.start;
            end = getOpeningParenOfParams(node, sourceCode).loc.start;
        }

        return {
            start: Object.assign({}, start),
            end: Object.assign({}, end)
        };
    },

    /**
     * Gets next location when the result is not out of bound, otherwise returns null.
     * @param {SourceCode} sourceCode The sourceCode
     * @param {{line: number, column: number}} location The location
     * @returns {{line: number, column: number} | null} Next location
     */
    getNextLocation(sourceCode, location) {
        const index = sourceCode.getIndexFromLoc(location);

        // Avoid out of bound location
        if (index + 1 > sourceCode.text.length) {
            return null;
        }

        return sourceCode.getLocFromIndex(index + 1);
    },

    /**
     * Gets the parenthesized text of a node. This is similar to sourceCode.getText(node), but it also includes any parentheses
     * surrounding the node.
     * @param {SourceCode} sourceCode The source code object
     * @param {ASTNode} node An expression node
     * @returns {string} The text representing the node, with all surrounding parentheses included
     */
    getParenthesisedText(sourceCode, node) {
        let leftToken = sourceCode.getFirstToken(node);
        let rightToken = sourceCode.getLastToken(node);

        while (
            sourceCode.getTokenBefore(leftToken) &&
            sourceCode.getTokenBefore(leftToken).type === "Punctuator" &&
            sourceCode.getTokenBefore(leftToken).value === "(" &&
            sourceCode.getTokenAfter(rightToken) &&
            sourceCode.getTokenAfter(rightToken).type === "Punctuator" &&
            sourceCode.getTokenAfter(rightToken).value === ")"
        ) {
            leftToken = sourceCode.getTokenBefore(leftToken);
            rightToken = sourceCode.getTokenAfter(rightToken);
        }

        return sourceCode.getText().slice(leftToken.range[0], rightToken.range[1]);
    },

    /*
     * Determine if a node has a possiblity to be an Error object
     * @param  {ASTNode} node  ASTNode to check
     * @returns {boolean} True if there is a chance it contains an Error obj
     */
    couldBeError(node) {
        switch (node.type) {
            case "Identifier":
            case "CallExpression":
            case "NewExpression":
            case "MemberExpression":
            case "TaggedTemplateExpression":
            case "YieldExpression":
            case "AwaitExpression":
                return true; // possibly an error object.

            case "AssignmentExpression":
                return module.exports.couldBeError(node.right);

            case "SequenceExpression": {
                const exprs = node.expressions;

                return exprs.length !== 0 && module.exports.couldBeError(exprs[exprs.length - 1]);
            }

            case "LogicalExpression":
                return module.exports.couldBeError(node.left) || module.exports.couldBeError(node.right);

            case "ConditionalExpression":
                return module.exports.couldBeError(node.consequent) || module.exports.couldBeError(node.alternate);

            default:
                return false;
        }
    },

    /**
     * Determines whether the given node is a `null` literal.
     * @param {ASTNode} node The node to check
     * @returns {boolean} `true` if the node is a `null` literal
     */
    isNullLiteral(node) {

        /*
         * Checking `node.value === null` does not guarantee that a literal is a null literal.
         * When parsing values that cannot be represented in the current environment (e.g. unicode
         * regexes in Node 4), `node.value` is set to `null` because it wouldn't be possible to
         * set `node.value` to a unicode regex. To make sure a literal is actually `null`, check
         * `node.regex` instead. Also see: https://github.com/eslint/eslint/issues/8020
         */
        return node.type === "Literal" && node.value === null && !node.regex && !node.bigint;
    },

    /**
     * Determines whether two tokens can safely be placed next to each other without merging into a single token
     * @param {Token|string} leftValue The left token. If this is a string, it will be tokenized and the last token will be used.
     * @param {Token|string} rightValue The right token. If this is a string, it will be tokenized and the first token will be used.
     * @returns {boolean} If the tokens cannot be safely placed next to each other, returns `false`. If the tokens can be placed
     * next to each other, behavior is undefined (although it should return `true` in most cases).
     */
    canTokensBeAdjacent(leftValue, rightValue) {
        let leftToken;

        if (typeof leftValue === "string") {
            const leftTokens = espree.tokenize(leftValue, { ecmaVersion: 2015 });

            leftToken = leftTokens[leftTokens.length - 1];
        } else {
            leftToken = leftValue;
        }

        const rightToken = typeof rightValue === "string" ? espree.tokenize(rightValue, { ecmaVersion: 2015 })[0] : rightValue;

        if (leftToken.type === "Punctuator" || rightToken.type === "Punctuator") {
            if (leftToken.type === "Punctuator" && rightToken.type === "Punctuator") {
                const PLUS_TOKENS = new Set(["+", "++"]);
                const MINUS_TOKENS = new Set(["-", "--"]);

                return !(
                    PLUS_TOKENS.has(leftToken.value) && PLUS_TOKENS.has(rightToken.value) ||
                    MINUS_TOKENS.has(leftToken.value) && MINUS_TOKENS.has(rightToken.value)
                );
            }
            return true;
        }

        if (
            leftToken.type === "String" || rightToken.type === "String" ||
            leftToken.type === "Template" || rightToken.type === "Template"
        ) {
            return true;
        }

        if (leftToken.type !== "Numeric" && rightToken.type === "Numeric" && rightToken.value.startsWith(".")) {
            return true;
        }

        return false;
    },

    /**
     * Get the `loc` object of a given name in a `/*globals` directive comment.
     * @param {SourceCode} sourceCode The source code to convert index to loc.
     * @param {Comment} comment The `/*globals` directive comment which include the name.
     * @param {string} name The name to find.
     * @returns {SourceLocation} The `loc` object.
     */
    getNameLocationInGlobalDirectiveComment(sourceCode, comment, name) {
        const namePattern = new RegExp(`[\\s,]${lodash.escapeRegExp(name)}(?:$|[\\s,:])`, "gu");

        // To ignore the first text "global".
        namePattern.lastIndex = comment.value.indexOf("global") + 6;

        // Search a given variable name.
        const match = namePattern.exec(comment.value);

        // Convert the index to loc.
        return sourceCode.getLocFromIndex(
            comment.range[0] +
            "/*".length +
            (match ? match.index + 1 : 0)
        );
    },

    /**
     * Determines whether the given raw string contains an octal escape sequence.
     *
     * "\1", "\2" ... "\7"
     * "\00", "\01" ... "\09"
     *
     * "\0", when not followed by a digit, is not an octal escape sequence.
     * @param {string} rawString A string in its raw representation.
     * @returns {boolean} `true` if the string contains at least one octal escape sequence.
     */
    hasOctalEscapeSequence(rawString) {
        return OCTAL_ESCAPE_PATTERN.test(rawString);
    }
};


text:
#ifndef PETABRICKSRIRCOMPILERPASS_H
#define PETABRICKSRIRCOMPILERPASS_H

#include "formula.h"
#include "rirscope.h"
#include "ruleir.h"
#include "trainingdeps.h"
#include "userrule.h"

#include "common/jprintable.h"

namespace petabricks {

class CodeGenerator;
class RuleInterface;
class Transform;

class RIRCompilerPass : public RIRVisitor {
protected:
  template<typename T> class Context {
  public:
    typedef std::list<T> TList;
    Context(TList* bk, TList* fw, int l)
      : _backward(bk), _forward(fw), _lvl(l)
    {}
    TList* backward() const { return _backward;}
    TList* forward () const { return _forward; }
    int    lvl     () const { return _lvl;     }
  private:
    TList* _backward;
    TList* _forward;
    int    _lvl;
  };
  typedef Context<RIRExprCopyRef> ExprContext;
  typedef Context<RIRStmtCopyRef> StmtContext;
  typedef std::vector<ExprContext> ExprContextStack;
  typedef std::vector<StmtContext> StmtContextStack;

  void pushExprForward(const RIRExprCopyRef& e){
    _exprCtx.back().forward()->push_front(e);
  }
  void pushExprBackward(const RIRExprCopyRef& e){
    _exprCtx.back().backward()->push_back(e);
  }
  bool hasExprBackward(){
    return !_exprCtx.back().backward()->empty();
  }
  bool hasExprForward(){
    return !_exprCtx.back().forward()->empty();
  }
  RIRExprRef peekExprForward() {
    JASSERT(!_exprCtx.back().forward()->empty()).Text("unexpected end of statement");
    RIRExprRef p = _exprCtx.back().forward()->front().asPtr();
    return p;
  }
  RIRExprRef popExprForward() {
    RIRExprRef p = peekExprForward();
    _exprCtx.back().forward()->pop_front();
    return p;
  }
  RIRExprRef peekExprBackward() {
    JASSERT(!_exprCtx.back().backward()->empty()).Text("unexpected end of statement");
    RIRExprRef p = _exprCtx.back().backward()->back().asPtr();
    return p;
  }
  RIRExprRef popExprBackward() {
    RIRExprRef p = peekExprBackward();
    _exprCtx.back().backward()->pop_back();
    return p;
  }
  void pushStmtForward(const RIRStmtCopyRef& s){
    _stmtCtx.back().forward()->push_front(s);
  }
  void pushStmtBackward(const RIRStmtCopyRef& s){
    _stmtCtx.back().backward()->push_back(s);
  }
  bool hasStmtForward(){
    return !_stmtCtx.back().forward()->empty();
  }

public:
  //void before(RIRExprCopyRef&) {}
  //void before(RIRStmtCopyRef&) {}
  //void before(RIRBlockCopyRef&){}
  //void after(RIRExprCopyRef&)  {}
  //void after(RIRStmtCopyRef&)  {}
  //void after(RIRBlockCopyRef&) {}

  //bool shouldDescend(const RIRNode&) { return true; }

  virtual void pushScope(){}
  virtual void popScope(){}

  virtual void beforeAny(const RIRNodeRef&){}
  virtual void afterAny(const RIRNodeRef&){}
protected:
  int depth() const { return _stack.size(); }

  RIRCompilerPass(const RIRScopePtr& scope = RIRScope::global()->createChildLayer()) : _scope(scope) {}

  const RIRNodeRef& parentNode() const { JASSERT(depth()>=2)(depth()); return _stack[_stack.size()-2]; }

private:
  void _before(RIRExprCopyRef& p)  {
    _beforeAny(p.asPtr());
    RIRVisitor::_before(p);
  }
  void _after(RIRExprCopyRef& p)   {
    RIRVisitor::_after(p);
    _afterAny(p.asPtr());
  }

  void _before(RIRStmtCopyRef& p)  {
    _beforeAny(p.asPtr());
    RIRVisitor::_before(p);
  }
  void _after(RIRStmtCopyRef& p)   {
    RIRVisitor::_after(p);
    _afterAny(p.asPtr());
  }

  void _before(RIRBlockCopyRef& p) {
    _scope=_scope->createChildLayer();
    pushScope();
    _beforeAny(p.asPtr());
    RIRVisitor::_before(p);
  }
  void _after(RIRBlockCopyRef& p)  {
    RIRVisitor::_after(p);
    _afterAny(p.asPtr());
    popScope();
    _scope=_scope->parentLayer();
  }
  void _beforeAny(const RIRNodeRef& n){
    _stack.push_back(n);
    beforeAny(n);
  }
  void _afterAny(const RIRNodeRef& n){
    afterAny(n);
    JASSERT(!_stack.empty());
    _stack.pop_back();
  }
  void pushSplicer(RIRStmtList* bk, RIRStmtList* fwd){
    _stmtCtx.push_back(StmtContext(bk, fwd, depth()));
  }
  void popSplicer(RIRStmtList* /*bk*/, RIRStmtList* /*fwd*/){
    JASSERT(!_stmtCtx.empty());
    _stmtCtx.pop_back();
  }
  void pushSplicer(RIRExprList* bk, RIRExprList* fwd){
    _exprCtx.push_back(ExprContext(bk, fwd, depth()));
  }
  void popSplicer(RIRExprList* /*bk*/, RIRExprList* /*fwd*/){
    JASSERT(!_exprCtx.empty());
    _exprCtx.pop_back();
  }
protected:
  std::vector<RIRNodeRef>_stack;
  ExprContextStack _exprCtx;
  StmtContextStack _stmtCtx;
  RIRScopePtr      _scope;
};

class GpuRenamePass : public RIRCompilerPass {
public:
  GpuRenamePass() : RIRCompilerPass(RIRScope::global()->createChildLayer()) {}
  void before(RIRExprCopyRef& e);
};

class DebugPrintPass : public RIRCompilerPass {
public:
  DebugPrintPass() : RIRCompilerPass(RIRScope::global()->createChildLayer()) {}
  void beforeAny(const RIRNodeRef& n){
    std::cout << std::string(depth()*2, ' ')
              << n->debugStr()
              << "   -- " << n->srcPos()
              << std::endl;
  }
};

class ExpansionPass : public RIRCompilerPass {
public:
  ExpansionPass(Transform& t, RuleInterface& r, const RIRScopePtr& p)
    : RIRCompilerPass(p->createChildLayer()), _transform(t), _rule(r)
  {}

  void before(RIRExprCopyRef& e);
  void before(RIRStmtCopyRef& e);
private:
  Transform&     _transform;
  const RuleInterface& _rule;
};

class AnalysisPass: public RIRCompilerPass {
public:
  AnalysisPass(RuleInterface& r, const std::string& name, const RIRScopePtr& p)
    : RIRCompilerPass(p->createChildLayer()), _name(name), _rule(r)
  {}

  void before(RIRExprCopyRef& e);

private:
  std::string _name;
  RuleInterface& _rule;
};

class LiftVardeclPass : public RIRCompilerPass {
public:
  LiftVardeclPass(Transform& t, RuleInterface& r, CodeGenerator& oo)
    : RIRCompilerPass(), o(oo), _transform(t), _rule(r)
  {}

  void before(RIRExprCopyRef& s);

protected:
  std::string prefix() const {
    std::ostringstream o;
    o << "b";
    if(_prefixStack.size()>1)
      jalib::JPrintable::printStlList(o, _prefixStack.begin(), _prefixStack.end()-1, "b");
    o << "local_";
    return o.str();
  }
  void pushScope(){
    if(_prefixStack.empty())
      _prefixStack.push_back(-1);
    JTRACE("pushScope")(_prefixStack.size());
    _prefixStack.back()++;
    _prefixStack.push_back(-1);
  }
  void popScope(){
    _prefixStack.pop_back();
    JTRACE("popScope")(_prefixStack.size());
  }
private:
  CodeGenerator& o;
  std::vector< int > _prefixStack;
  const Transform&     _transform;
  const RuleInterface& _rule;
};

class RuleFlavorSpecializePass : public RIRCompilerPass {
public:
  RuleFlavorSpecializePass(RuleFlavor rf)
    : RIRCompilerPass(), _rf(rf)
  {}

  void before(RIRExprCopyRef& s);
private:
  RuleFlavor _rf;
};

class DynamicBodyPrintPass : public RIRCompilerPass {
public:
  DynamicBodyPrintPass(CodeGenerator& oo )
    : RIRCompilerPass(), o(oo)
  {}

  void before(RIRStmtCopyRef& s);

  bool shouldDescend(const RIRNode& n) { return !n.isStmt(); }
private:
  CodeGenerator& o;
  std::vector<std::string> _breakTargets;
  std::vector<std::string> _continueTargets;
};

class OpenClCleanupPass: public RIRCompilerPass {
public:
  class NotValidSource {};
  OpenClCleanupPass(UserRule& r, const RIRScopePtr& p)
    : RIRCompilerPass(p->createChildLayer()), _rule(r)
  {}
  void before(RIRExprCopyRef& e);
  void setLocalMemoryData(std::set<std::string>& locals, int id) {
    _locals = locals;
    _id = id;
  }
private:
  void generateAccessor( const RegionPtr& region, const FormulaPtr& x, const FormulaPtr& y );
  std::vector<std::string> generateCellIndices(RIRExprList& tokens);
  UserRule& _rule;
  std::set<std::string> _locals;
  std::map<std::string, FormulaList> _minCoordOffsets;
  std::map<std::string, FormulaList> _maxCoordOffsets;
  int _id;
};

class OpenClFunctionRejectPass: public RIRCompilerPass {
 public:
  class NotValidSource {};
  OpenClFunctionRejectPass(UserRule& r, const RIRScopePtr& p)
    : RIRCompilerPass(p->createChildLayer()), _rule(r)
  {}
  void before(RIRExprCopyRef& e);
 private:
  bool isFunctionAllowed( const std::string& fn );
  bool isIdentBlacklisted( const std::string& ident );
  UserRule& _rule;
};

class CollectLoadStorePass: public RIRCompilerPass {
 public:
  class NotValidSource {};

  CollectLoadStorePass(UserRule& r, const RIRScopePtr& p): RIRCompilerPass(p->createChildLayer()), _rule(r)
  {
    _computeloads = false;
    _istrans = false;
  }
  void before(RIRExprCopyRef& e);
  void before(RIRStmtCopyRef& e);
  void after(RIRStmtCopyRef& e);

  RegionSet& stores() {
    return _stores;
  }

  RegionSet& loads() {
    /* if(!_computeloads) { */
    /*   _computeloads = true; */
    /*   for(RegionSet::iterator i = _loadstores.begin(); i != _loadstores.end(); ++i) { */
    /* 	if(_stores.find(*i) == _stores.end()) */
    /* 	  _loads.insert(*i); */
    /*   } */
    /* } */
    return _loads;
  }

 private:
  UserRule& _rule;
  RegionSet _stores;
  RegionSet _loads;
  RegionSet _loadstores;
  bool _computeloads;
  bool _istrans;

  RIRExprCopyRef _firstInStmt;
  bool _addFirst;
  int _numExprs;
};

class ManageCpuGpuMemPass: public RIRCompilerPass {
 public:
  class NotValidSource {};
 ManageCpuGpuMemPass(UserRule& r, const RIRScopePtr& p, RegionSet& loads, RegionSet& stores)
   : RIRCompilerPass(p->createChildLayer()), _rule(r), _loads(loads), _stores(stores)
  {
    _state = 0;
    _beforetrans = true;
    _addfront = false;
  }
  int state() {
    return _state;
  }
  bool addfront() {
    return _addfront;
  }
  void before(RIRExprCopyRef& e);
  void before(RIRStmtCopyRef& e);
 private:
  UserRule& _rule;
  RIRExprCopyRef _insertbefore;
  RegionSet& _loads;
  RegionSet& _stores;

  int _state;
  bool _beforetrans;
  bool _addfront;
};

}

#endif


text:
package libppc

import "ppc/libppc/interfaces"

type State struct {
	Router *Router

	Devices *DeviceStorage
}

func (s *State) GetAllDevices() []interfaces.IDevice {
	return s.Devices.GetAllDevices()
}

func (s *State) CreateNewDevice(address uint, name string, deviceType uint) (interfaces.IDevice, error) {
	return s.Devices.CreateNewDevice(address, name, deviceType)
}

func NewState(database interfaces.IDatabase, manager interfaces.IBusManager) (*State, error) {
	state := &State{}
	state.Router = NewRouter(manager)

	state.Devices = NewDeviceStorage(database, state.Router)
	devices, err := state.Devices.LoadFromDB()
	if err != nil {
		return nil, err
	}

	for i := range devices {
		device := devices[i]
		device.Enable()
	}

	return state, nil
}